C++：类和对象

• c语言的struct只有变量
• c++语言的struct既有变量也有函数

• 将属性和行为作为一个整体
• 将属性和行为添加权限控制
  class默认权限是私有权限，struct默认权限是公共权限
• 访问权限

成员函数与全局函数比较类时，成员函数只需传入一个参数，全局函数需要传入两个需要比较的类

class Cube {
public:
	void setL(int l) {
		m_l = l;
	}
	int getL() {
		return m_l;
	}

	void setW(int w) {
		m_w = w;
	}
	int getW() {
		return m_w;
	}

	void setH(int h) {
		m_h = h;
	}
	int getH() {
		return m_h;
	}

	int calculateS() {
		return (m_l*m_w+m_l*m_h+m_w*m_h)*2;
	}
	int calculateV() {
		return m_l * m_w * m_h;
	}
	//成员函数，成员变量与另一实例的成员变量做对比
	bool compareCudeTo(Cube& c) {
		return m_l == c.getL()&& m_w == c.getW() && m_h == c.getH();
	}

private:
	int m_l;
	int m_w;
	int m_h;
};
//全局函数
bool compareCude(Cube &c1, Cube &c2) {
	return c1.getL()==c2.getL()&&c1.getW()==c2.getW()&&c1.getH()==c2.getH();
}

头文件

#ifndef __POINT_H__
#define __POINT_H__

#define _CRT_SECURE_NO_WARNINGS
#include
using namespace std;

class Point {
private:
	int m_x;
	int m_y;
public:
	int getX();
	void setX(int x);

	int getY();
	void setY(int y);
};

#endif // !__POINT_H__

.c文件:方法名前加作用域

#include"point.h"

int Point::getX() {
	return m_x;
}
void Point::setX(int x) {
	m_x = x;
}

int Point::getY() {
	return m_y;
}
void Point::setY(int y) {
	m_y = y;
}

#define _CRT_SECURE_NO_WARNINGS
#include
using namespace std;

class Person {
public://构造函数和析构函数必须要声明在全局作用域
	
	//构造函数:对象创建时调用
	//没有返回值，不用写void
	//函数名和类名相同
	//可以有参数，可以重载
	//构造函数编译器自动调用1次，无需手动调用
	Person() {
		cout << "Person的构造函数调用" << endl;
	}

	//析构函数：对象销毁时调用
	//没有返回值，不用写void
	//函数名与类名相同，函数名前加~
	//不可以有参数，不可以重载
	//析构函数由编译器自动调用1次，无需手动调用
	~Person() {
		cout << "Person的析构函数调用" << endl;
	}
};

void tets0301() {
	Person p;
}

int main()
{
	tets0301();
	return EXIT_SUCCESS;
}

• 构造函数的分类

//构造函数分类
//按参数分类：无参构造、有参构造
//按类型分类：普通构造、拷贝构造
class Person {
public:
	Person() {
		cout << "无参构造" << endl;
	}
	Person(int a) {
		m_age = a;
		cout << "有参构造" << endl;
	}
	//拷贝构造
	Person(const Person &p) {
		m_age = p.m_age;
	}

	int m_age;
};

• 构造函数的调用

//构造函数调用
void test0401() {
	//1.括号法
	Person p;//无参构造，无参构造不能带括号，否则存在是函数定义的歧义
	Person p1(18);//有参构造
	Person p2(p1);//拷贝构造
	//2.显示法
	Person p3 = Person();
	Person p4 = Person(18);
	Person p5 = Person(p1);
	
	//匿名对象，特点：当前行执行完后立即释放
	Person(10);
	//不能用拷贝构造初始化匿名对象，编译器会认为该语法重定义了引用对象
	//Person(p1);

	//3.隐式法
	Person p6 = 10;//等价于Person p6 = Person(10)
	Person p7 = p1;//等价于Person p7 = Person(p1)
}

• 拷贝构造函数的调用时机

//用已经创建好的对象初始化新对象
void tets0501() {
	Person05 p1(18);
	Person05 p2 = Person05(p1);

	cout << "p2的年龄:" << p2.m_age << endl;
}
//值传递的方式，给函数参数传值
void doWork(Person05 p) {
	
}
void test0502() {
	Person05 p1(100);
	doWork(p1);
}

//以值的方式返回局部对象
Person05 doWork2() {
	Person05 p;
	return p;
}
void test0503() {
	Person05 p = doWork2();
}

• 构造函数调用规则

1. 编译器会给一个类至少添加3个函数，默认构造（空实现），析构（空实现），拷贝构造（值拷贝）
2. 用户自定义有参构造后，编译器不会提供默认无参构造，但是会提供拷贝构造函数
3. 用户自定义拷贝构造函数时，编译器不会提供其他构造函数

• 构造函数的初始化列表

class Person {
public:
	Person(int a, int b, int c) {
		m_a = a;
		m_b = b;
		m_c = c;
	}
	//默认值初始化
	Person() :m_a(10), m_b(20), m_c(30) {
		
	}
	//用户提供初始化值
	Person(int a, int b, int c) :m_a(a), m_b(b), m_c(c) {

	}
	int m_a;
	int m_b;
	int m_c;
};

深拷贝：开辟新空间，新旧对象指向不同空间
浅拷贝：新旧对象指向相同空间，会造成重复释放空间的异常

用途：防止利用隐式类型转换方式来构造对象

class MyString {
public:
	MyString(const char* str) {
		
	}
	explicit MyString(int len) {

	}
};

void test1001() {
	MyString str("abcd");
	MyString str2(10);
	//添加explicit关键字后不能使用该方式初始化
	//MyString str3 = 10;
}

1. mallocs和free属于库函数，new和delete属于运算符
2. malloc不会调用构造函数，new会调用构造函数
3. malloc返回void*，new返回创建的对象的指针

不能使用void*接收new出来的对象，void*接收的对象delete时不会调用析构函数

class Person11 {
public:
	Person11() {
		cout << "构造函数" << endl;
	}

	~Person11() {
		cout << "析构函数" << endl;
	}
};

void test1101() {
	Person11* p = new Person11();
	delete p;

	Person11* pArray = new Person11[10];
	delete[] pArray;
}