C++(三)——类和对象(上)

构造函数

#include<iostream>
using namespace std;

class Person {
public:
	int age;
	Person() {
		cout << "无参构造" << endl;
	}
	Person(int a) {
		age = a;
		cout << "有参构造" << endl;
	}
	//拷贝构造参数
	Person(const Person &p) {
		age = p.age;
		cout << "拷贝构造" << endl;
	}

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

};
int main1() {
//	Person p1;//无参构造
//	Person p2(10);//有参构造
//	Person p3(p2);//拷贝构造
	//cout << "p2的age=" << p2.age << endl;
	//cout << "p3的age=" << p3.age << endl;

	//调用默认构造函数时不加()
	//2.显示法
	Person p1;
	Person p2 = Person(15);
	Person p3 = Person(p2);

	//注意事项，不要利用拷贝构造函数来初始化一个匿名对象, 编译器会认为是对象的声明
	//Person(p3);

	//3.隐式转换法
	//Person p4 = 10; //
	//Person p5 = p4;
	return 0;
}

深拷贝与浅拷贝

#include<iostream>
using namespace std;
class Person {
public:
	int m_age;
	int* m_height;
	Person() {
		cout << "无参构造" << endl;
	}
	Person(int age, int height) {
		m_age = age;
		m_height = new int(height);
		cout << "有参构造" << endl;
	}
	//省略此步即为浅拷贝，编译器默认的拷贝构造函数为浅拷贝，析构时会重复释放指针导致报错

	//Person(const Person &p) {
	//	m_age = p.m_age;
	//	m_height = new int(*p.m_height);
	//	cout << "拷贝构造" << endl;
	//}
	~Person() {
		if (m_height != NULL) {
			delete(m_height);
			m_height = NULL;
		}
		cout << "析构函数" << endl;
	}

};
void testG() {
	Person p1(15, 177);
	Person p2(p1);
	cout << "p1的age = " << p1.m_age << " p1的height = " << *p1.m_height<< endl;
	cout << "p2的age = " << p2.m_age << " p2的height = " << *p2.m_height<< endl;

}
int main() {

	testG();
	return 0;

}

对象特性——初始化列表

#include<iostream>
using namespace std;
class Person {
public:
	int m_a;
	int m_b;
	int m_c;
	Person(int a, int b, int c) :m_a(a), m_b(b), m_c(c) {


	}


};
void test() {
	Person p(15, 25, 0);
	cout << p.m_a << endl;
	cout << p.m_b << endl;
	cout << p.m_c << endl;


}

int main() {
	test();

}

类对象作成员

#include<iostream>
using namespace std;
class Phone {
public:
	string m_phoneName;
	Phone(string phoneName) {
		m_phoneName = phoneName;
		cout << "构造phone" << endl;
	}
	~Phone() {
		cout << "析构phone" << endl;
	}
};

class Person {
public:
	Phone m_p;
	string m_name;
	Person(string phoneName, string name) :m_p(phoneName), m_name(name)
	{
		cout << "构造person" << endl;

	}
	~Person() {
		cout << "析构person" << endl;
	}
};

void test() {
	Person p("iPhone", "motherfucker");
	cout << p.m_p.m_phoneName << endl;
	cout << p.m_name << endl;

};


int main() {


	test();

	return 0;
}
//打印结果，注意先构造对象成员，析构时顺序相反


//构造phone
//构造person
//iPhone
//motherfucker
//析构person
//析构phone

静态成员——静态函数

#include<iostream>
using namespace std;
class Person {
public:
	int m_b;
	static void func() {
		cout << "调用静态函数" << endl;
		s_a = 100;
		//m_b = 0;静态成员函数只能访问静态变量，不能访问成员变量
	}
private:
	static int s_a;


};
int Person::s_a = 0;
void test() {
	
	Person p;
	p.func();
	Person::func;
}

int main() {
	test();
	return 0;
}

成员变量与成员函数分开存储

#include<iostream>
using namespace std;
//成员变量和成员函数分开存储
class Person {
	int m_A;//非静态成员变量 属于类的对象上
	static int m_b;//静态的成员变量与成员函数 不属于类的对象上
	void func(){}//非静态 不属于类的对象上
	 
};
void test01() {
	Person p;
	//空对象占用空间1个字节
	//c++编译器给空对象分配一个字节空间，是为了区分空对象占用的位置
	//每个空对象都有一个独一无二的内存地址
	cout << "size of p = " << sizeof(p) << endl;
}
int main() {
	test01();
}