文章目录
一、封装
1.封装的意义
2.struct和class区别
3.成员属性设置为私有
二、对象的初始化和清理
1.构造函数好析构函数
2.构造函数的分类及调用
#include<iostream>
using namespace std;
//按参数分类 无参构造(默认构造)和 有参构造
//按类型分类 普通构造 和 拷贝构造
class Person
{
public:
普通构造函数
//无参构造函数
Person()
{
cout << "Person的无参构造函数调用" << endl;
}
//有参构造函数
Person(int a)
{
age = a;
cout << "Person的有参构造函数调用" << endl;
}
拷贝构造函数
Person(const Person& p)
{
//将传入的人身上的所有属性,拷贝到我身上
cout << "Person的拷贝构造函数调用" << endl;
age = p.age;
}
~Person()
{
cout << "Person的析构函数调用" << endl;
}
int age;
};
//调用
void test01()
{
//以下三选一
//1.括号法,常用
Person p1;//无参构造函数调用//注意事项:不要加()
Person p2(10);//有参构造函数调用
Person p3(p2);//拷贝构造函数调用
cout << "p2的年龄为" << p2.age << endl;
cout << "p3的年龄为" << p3.age << endl;
//2.显示法
/*
Person p1;
Person p2 = Person(10);//有参构造
Person p3 = Person(p2);//拷贝构造
//注意事项1:
Person(10);//匿名对象 特点:当前行执行结束后,系统会立即回收掉匿名对象
cout << "hhhhhhhh" << endl;
//注意事项2:
//Person(p3);
//不要利用拷贝构造函数初始化匿名对象,编译器会认为 Person(p3) === Person p3,对象重名
*/
//3.隐式转换法
/*
Person p4 = 10;//相当于写了 Person p4 = Person(10);//有参构造
Person p5 = p4;//拷贝构造
*/
}
int main()
{
test01();
return 0;
}
3.拷贝构造函数调用时机
4.构造函数调用规则
5.深拷贝与浅拷贝
#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 = p.m_Height;//编译器默认实现就是这行代码
//深拷贝操作
m_Height = new int(*p.m_Height);
}
~Person()
{
//析构代码,将堆区开辟数据做释放操作
if (m_Height != NULL)
{
delete m_Height;
m_Height = NULL;
}
cout << "Person的析构构造函数调用" << endl;
}
int m_Age;
int* m_Height;
};
void test01()
{
Person p1(18,180);
cout << "p1的年龄为" << p1.m_Age << " 身高为" << *p1.m_Height << endl;
Person p2(p1);
cout << "p2的年龄为" << p2.m_Age << " 身高为" << *p2.m_Height << endl;
}
int main()
{
test01();
return 0;
}
6.初始化列表
7.类对象作为类成员
#include<iostream>
using namespace std;
#include <string.h>
//手机类
class Phone
{
public:
Phone(string pName)
{
cout << "Phone的构造函数调用" << endl;
m_PName = pName;
}
~Phone()
{
cout << "Phone的析构函数调用" << endl;
}
//手机品牌名称
string m_PName;
};
//人类
class Person
{
public:
Person(string name, string pName) :m_Name(name), m_Phone(pName)
{
cout << "Person的构造函数调用" << endl;
}
~Person()
{
cout << "Person的析构函数调用" << endl;
}
//姓名
string m_Name;
Phone m_Phone;
};
//当其他类成员作为本类成员,构造时候先构造类对象,再构造自身
//析构的顺序:与构造相反
void test01()
{
Person p("张三", "华为");
cout << p.m_Name << "拿着" << p.m_Phone.m_PName << endl;
}
int main()
{
test01();
return 0;
}
8.静态成员
静态成员变量
#include<iostream>
using namespace std;
class Person
{
public:
//1.所有对象都共享同一份数据
//2.编译阶段就分配内存
//3.类内声明,类外初始化操作
static int m_A;
private:
static int m_B;
};
int Person::m_A = 100;
//int Person::m_B = 200;//类外访问不到私有静态成员变量
void test01()
{
Person p;
cout << p.m_A << endl;
Person p2;
p2.m_A = 200;
cout << p2.m_A << endl;
}
void test02()
{
//静态成员变量 不属于某个对象上,所有对象都共享同一份数据
//因此静态成员变量有两种访问方式
//1.通过对象进行访问
Person p;
cout << p.m_A << endl;
//2.通过类名进行访问
cout << Person::m_A << endl;
}
int main()
{
//test01();
test02();
return 0;
}
静态成员函数
#include<iostream>
using namespace std;
//静态成员函数
//所有对象共享同一个函数
//静态成员函数只能访问静态成员变量
class Person
{
public:
//静态成员函数
static void func()
{
m_A = 100;//静态成员函数 可以访问 静态成员变量
//m_B = 100;//静态成员函数 不可以访问 非静态成员变量//因为无法区分到底是哪个对象的m_B属性
cout << "static void func调用" << endl;
}
static int m_A;//静态成员变量
int m_B;//非静态成员变量
//静态成员函数也是有访问权限的
private:
static void func2()
{
cout << "static void func2调用" << endl;
}
};
int Person::m_A = 0;
//有两种访问方式
void test01()
{
//1.通过对象访问
Person p;
p.func();
//2.通过类名访问
Person::func();
//Person::func2();//类外访问不到私有静态成员函数
}
int main()
{
test01();
return 0;
}