C++复习--04

构造函数语法： 类名 (){}

1. 构造函数，没有返回值也不写 void

2. 函数名称与类名相同

3. 构造函数可以有参数，因此可以发生重载

4. 程序在调用对象时候会自动调用构造，无须手动调用 , 而且只会调用一次

析构函数语法： ~ 类名 (){}

1. 析构函数，没有返回值也不写 void

2. 函数名称与类名相同 , 在名称前加上符号 ~

3. 析构函数不可以有参数，因此不可以发生重载

4. 程序在对象销毁前会自动调用析构，无须手动调用 , 而且只会调用一次

默认情况下，c++编译器至少给一个类添加3个函数

{

1.默认构造函数（无参，函数体为空）

2.默认析构函数（无参，函数体为空）

3.默认拷贝构造函数，对属性进行值拷贝

构造函数调用规则

1.定义有参构造，c++不会提供默认无参，会提供拷贝构造

2.定义拷贝构造，不会提供其他构造

深拷贝与浅拷贝

#include<iostream>
using namespace std;
class Person {
public:
	Person()
	{
		cout << "Person的默认构造函数调用" << endl;
	}
	Person(int age,int height)
	{
		m_age = age;
		m_height=new int(height);//深拷贝
		cout << "Person的有参构造函数调用" << endl;
	}
	//自己实现拷贝构造函数，解决浅拷贝带来的问题
	Person(const Person& p)
	{
		cout << "Person 拷贝构造函数调用" << endl;
		m_age = p.m_age;
		m_height=new int(*p.m_height);
	}
	int m_age;
	int* m_height;
	~Person()//将堆区开辟的数据释放
	{
		if (m_height != NULL)
		{
			delete m_height;
			m_height = NULL;
		}
		cout << "Person的析构构造函数调用" << endl;
	}
};
void test01()
{
	Person p1(18,185);
	cout << "p1的年龄为：" << p1.m_age<<*p1.m_height;
	Person p2(p1);
	cout << "p2的年龄为：" << p2.m_age<<*p1.m_height;
}
int main()
{
	test01();
}

初始化列表方式初始化

语法：

Person (int a,int b,int c):m_A(a),m_B(b),m_C(c);{}

Person p(1,2,3);

静态成员：

一.静态成员变量：

static int a;

特点：1.类内声明，类外初始化

类外：int Person ::a=10;

2.所有成员共享一份数据

静态成员通过两种方式访问：

1.通过对象

Person p1;

p1.a;

2.通过类名//不属于某个对象

Person::a;

静态成员变量也具有访问权限

二、静态成员函数

特点 ：1.程序共享一个函数

2.静态成员函数只能访问静态成员变量

静态成员函数也具有访问权限

也具有两种访问方式：1.通过对象 2.通过类名

c++中，类的成员函数和成员变量分开存储

只有非静态成员变量才属于类的对象上，static不属于任何一个对象

空对象占用的内存空间是1，c++会给每个空对象分配一个字节的内存是为了区分空对象占内存的位置

this指针指向被调用的成员函数所属的对象

this指针隐含在每一个非静态成员函数内，无需定义，直接使用

意义：1.解决形参与成员变量同名的问题

2.类的非静态成员函数返回对象本身，使用return *this

Person (int age)
{
    this->age=age;
}
int age

Person& add(Person &p)
{
    this->age+=p.age;
    return *this;
}

p.add(p1).add(p1).add(p1);

空指针可以调用成员函数；但如果成员函数中含有this指针，

需要写

if（this==NULL）

{

        return ;

}

常函数不可以修改成员属性

成员函数后加const就叫常含数

成员属性加mutable后，常含数依然可以修改

常对象只能调用常含数

全局函数做友元

#include<iostream>
using namespace std;
#include <string>
class Building {
	//goodgay 可以访问Building中的私有成员
	friend void goodgay(Building* building);
public:
	Building(){
		m_settingroom = "客厅";
		m_bedroom = "卧室";
	}
public:
	string m_settingroom;
private:
	string m_bedroom;
};
void goodgay(Building* building)
{
	cout << "好朋友正在访问：" << building->m_settingroom << endl;
	cout << "好朋友正在访问：" << building->m_bedroom << endl;

}
int main()
{
	Building building;
	goodgay(&building);

}

类做友元

#include<iostream>
using namespace std;
#include <string>
class Goodgay {
public:
	Goodgay();
	void visit();
private:
	Building *building;
};
class Building {
	friend class Goodgay;
public:
	string m_settingroom;
private:
	string m_bedroom;
public:
	Building();
};
Building::Building()
{
	this->m_settingroom = "客厅";
	this->m_bedroom = "卧室";
}
Goodgay::Goodgay()
{
	building = new Building;
}
void Goodgay::visit()
{
	cout<<"好基友正在访问"<<building->m_bedroom<<endl;
}
int main()
{
	Goodgay gg;
	gg.visit();
}

成员函数做友元

#include<iostream>
using namespace std;
#include<string>
class goodgay {
public:
	goodgay();
	
	void visit();//可以访问Building中私有成员
	void visit2();//不可以访问Building中私有成员
private:
	Building* building;
};
class Building {
	friend void goodgay:: visit();
public:
	string m_settingroom;
private:
	string m_bedroom;
public:
	Building();
};
Building::Building()
{
	this->m_settingroom = "客厅";
	this->m_bedroom = "卧室";
}
goodgay::goodgay()
{
	building = new Building;
}
void goodgay::visit()
{
	cout << building->m_bedroom;
}
void goodgay::visit2()
{
	cout << building->m_settingroom;
}
int main()
{
	goodgay gg;
	gg.visit();
	gg.visit2();
}