文章目录
一、类和对象
1.封装
2.对象的初始化和清理
（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 ,160);
cout << "p1的年龄为：" << p1.m_age ;
cout << " p1的身高为：" << *p1.m_height << endl;
person p2(p1);
cout << "p2的年龄为：" << p2.m_age;
cout << " p2的身高为：" << *p2.m_height << endl;
}
int main()
{
test01();
system("pause");
return 0;
}
（6）初始化列表
作用：C++提供了初始化列表语法，用来初始化属性
语法：构造函数 （ ）：属性1（值1），属性2（值2）......{ }
示例
#include<iostream>
using namespace std;
//初始化列表
class person
{
public:
//传统初始化操作
//person(int a, int b, int c)
//{
// m_A = a;
// m_B = b;
// m_C = c;
//}
//初始化列表初始化属性
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;
};
void test01()
{
//person p(1, 2, 3);
person p(30, 20, 10);
cout << "m_A = " << p.m_A << endl;
cout << "m_B = " << p.m_B << endl;
cout << "m_C = " << p.m_C << endl;
}
int main()
{
test01();
system("pause");
return 0;
}
（7）类对象作为类成员
C++中的成员可以是另一个类的对象，我们称该成员为对象成员
当其他类对象作为本类成员，构造时候先构造类对象，再构造自身
例如
class A {
}
class B
{
A a;
}
B类中有对象A作为成员，A为对象成员
示例
#include<iostream>
using namespace std;
#include<string>
//类对象作为类成员
//手机类
class phone
{
public:
phone(string pname)
{
m_Pname = pname;
cout << "phone的构造函数调用" << endl;
}
//手机品牌名
string m_Pname;
};
class person
{
public:
person(string name, string pname) :m_name(name), m_phone(pname)
{
cout << "person的构造函数调用" << endl;
}
string m_name; //姓名
phone m_phone;//手机品牌
};
void test01()
{
person p("张三", "三星");
cout << p.m_name << endl;
cout << p.m_phone.m_Pname << endl;
}
int main()
{
test01();
system("pause");
return 0;
}
输出结果
（8）静态成员
静态成员就是在成员变量和成员函数前加上关键字static，称为静态成员
静态成员分为：
1* 静态成员变量
- 所有对象共享同一份数据
- 在编译阶段分配内存
- 类内声明，类外初始化
2* 静态成员函数
- 所有对象共享同一个函数
- 静态成员函数只能访问静态成员变量
静态成员函数也是有访问权限的：类外访问不到私有静态成员函数
示例
#include<iostream>
using namespace std;
#include<string>
//静态成员函数
class person
{
public:
static void func()
{
A = 20;
//B = 20;//静态成员函数不可访问非静态成员变量，无法区分是哪个对象的属性
cout << "static void func调用" << endl;
}
static int A;//静态成员变量
int B;//非静态变量成员
};
int person::A = 0;
//两种访问方式
void test01()
{
//1、通过对象访问
person p;
p.func();
//2、通过类名访问
person::func();
}
int main()
{
test01();
system("pause");
return 0;
}
3.C++对象模型和this指针
（1）成员变量和成员函数分开存储
在C++中，类内的成员变量和成员函数分开存储
只有非静态成员变量才属于类的对象上
C++编译器会给每个空对象分配一个字节空间，是为了区分对象所占内存位置，每个空对象都应该有一个独一无二的内存地址
- 非静态成员变量：属于类的对象上
- 静态成员变量：不属于类的对象上
- 非静态成员函数：不属于类的对象上
- 静态成员函数：不属于类的对象上
（2）this指针概念
this指针的本质是指针常量，指针的指向是不可以修改的，但是值可以修改
每一个非静态成员函数只会诞生一份函数实例，也就是说多个同类型的对象会共用一块代码
C++通过提供特殊的对象指针，this指针，解决上述问题
this指针指向被调用的成员函数所属的对象
- this指针是隐含每一个非静态成员函数内的一种指针
- this指针不需要定义，直接使用即可
this指针的用途：
- 当形参和成员变量同名时，可用this指针来区分（解决名称冲突）
- 在类的非静态成员函数中返回对象本身，可使用return this（返回对象本身用this）
示例
#include<iostream>
using namespace std;
class person
{
public:
person(int age)
{
//this 指针指向的是被调用的成员函数所属对象
this->age = age;
}
person& personAddage(person &p)
{
this->age += p.age;
//this指向p2的指针，而*this指向的就是p2这个对象本体
return *this;
}
int age;
};
//1、解决名称冲突
void test01()
{
person p1(18);
cout << "p1的年龄为：" << p1.age << endl;
}
//2、返回对象本身
void test02()
{
person p1(10);
person p2(10);
//链式编程思想
p2.personAddage(p1).personAddage(p1);
cout << "p2的年龄为：" << p2.age << endl;
}
int main()
{
test02();
system("pause");
return 0;
}
（3）空指针访问成员函数
C++中空指针也是可以调用成员函数的，但是也要注意有没有用到this指针
如果用到this指针，需要加以判断保证代码的健壮性
示例
#include<iostream>
using namespace std;
class person
{
public:
void showClassName()
{
cout << "this is person class" << endl;
}
void showPersonAge()
{
if (this == NULL)
return;
cout << "age = " << m_age << endl;
}
int m_age;
};
//1、解决名称冲突
void test01()
{
person *p = NULL;
p->showClassName();
p->showPersonAge();
}
int main()
{
test01();
system("pause");
return 0;
}
（4）const修饰成员函数
常函数：
- 成员函数后加const后我们称这个函数为常函数
- 常函数内不可修改成员属性
- 成员属性声明时加关键字mutable后，在常函数中依然可以修改
常对象：
- 声明对象前加const称该对象为常对象
- 常对象只能调用常函数
示例
#include<iostream>
using namespace std;
class person
{
public:
//在成员函数后面加const，修饰的是this指向，让指针指向的值也不可修改
void showPerson()const
{
m_b = 100;//可修改
}
int m_age;
mutable int m_b;//特殊变量
};
void test01()
{
person p;
p.showPerson();
}
//常对象
//常对象只能调用常函数
void test02()
{
const person p;
//p.m_age = 100;
p.m_b = 100;
}
int main()
{
test01();
system("pause");
return 0;
}
【注释】 学习课程为-黑马程序C++教程