类与对象
c++面向对象3大特性：封装、继承、多态
c++认为万事万物皆为对象，对象上有其属性和行为
封装
封装是面向对象3大特性之一
意义
- 将属性和行为作为一个整体，表现生活中的事务
- 将属性和行为加以权限控制
语法
class 类名 ｛访问权限 属性\行为｝
类中的属性和行为统称为成员
类中的属性称为：成员属性或成员变量
类中的行为称为：成员函数或成员方法
访问权限
- public 公共权限
成员 类内可以访问 ，类外也可以访问 - protected 保护权限
成员 类内可以访问， 类外不可以访问
子类可以访问父类保护权限的内容 - private 私有权限
成员 类内可以访问 ，类外不可以访问
子类不可以访问父类的私有权限内容
struct 和 class 的区别
在c++中，struct和class的唯一区别就是：默认的访问权限不同
struct的默认访问权限是：公共权限
class的默认访问权限是：私有权限
成员属性私有化
优点：
- 将所有成员属性设置为私有，可以自己控制读写权限
- 对于写权限，我们可以检测数据的有效性
应用：
将类中的属性设置为私有，可以通过设置set和get方法来控制
对象的初始化和清理
对象的初始化和清理是两个非常重要的安全问题
c++利用构造函数和析构函数解决这两个问题
构造和析构函数都是必须的，如果我们不写，则系统默认会写一个空实现
构造函数和析构函数
构造函数
主要作用在于创建对象时为对象的成员属性赋值，构造函数由编译器自动调用，无需手动调用
语法：
类名（）{}
- 没有返回值，也不写void
- 函数名称和类名相同
- 构造函数可以有参数，因此可以发生重载
- 程序在调用对象时，会自动调用构造，无需手动调用，而且只会调用一次
构造函数的分类和调用
两种分类方式：
按参数分类：有参构造和无参构造
按类型分类：普通构造和拷贝构造
三种调用方式：
括号法
显示法
隐式转换法
注意事项：
- 不要用括号法调用无参构造
- 不要用拷贝构造初始化匿名对象，因为系统会认为 Person § === Person p ;
这样会报错，显示重定义错误
#include<iostream>
using namespace std;
//构造函数的分类和调用
class Person {
public:
int m_age;
Person() {
cout << "Person的无参构造" << endl;
}
Person(string name,int age) {
m_age = age;
cout << "Person的有参构造" << endl;
}
Person(const Person& p) {
m_age = p.m_age;
cout << "Person的拷贝构造" << endl;
}
~Person() {
cout << "Person的析构函数" << endl;
}
};
//调用
void test01() {
//1.括号法
Person p;
Person p2("张三", 30);
Person p3(p2);
cout << "p2的年龄" << p2.m_age << endl;
cout << "p3的年龄" << p3.m_age << endl;
//2.显示法
Person p4;
Person p5 = Person("里斯", 70);
Person p6 = Person(p5);
cout << "p5的年龄" << p5.m_age << endl;
cout << "p6的年龄" << p6.m_age << endl;
Person("作者", 90);//匿名对象 当前行执行结束，系统会立即回收匿名对象
cout << "aaaaaaaaaaaa" << endl;
//3.隐式转换法
Person p7 = p6;
}
int main() {
test01();
system("pause");
return 0;
}
拷贝函数的调用情景
c++调用拷贝函数一般有3种情况
- 使用一个已创建的对象来初始化一个新的对象
- 值传递的方式来给函数参数传值
- 以值方式返回局部对象
#include<iostream>
using namespace std;
//拷贝构造函数调用情景
class Person {
public:
int m_age;
Person() {
cout << "Person的无参构造" << endl;
}
Person(string name, int age) {
m_age = age;
cout << "Person的有参构造" << endl;
}
Person(const Person& p) {
m_age = p.m_age;
cout << "Person的拷贝构造" << endl;
}
~Person() {
cout << "Person的析构函数" << endl;
}
};
//调用
void doWork(Person p) {
}
void test01() {
// 1.使用一个已创建的对象来初始化一个新的对象
Person p;
Person p0 = Person(p);
}
void test02() {
//2.值传递的方式来给函数参数传值
Person p1;
doWork(p1);
}
Person doWork2() {
Person p2;
cout << (int)&p2 << endl;
return p2;
}
void test03() {
Person p3 = doWork2();
cout << (int)&p3 << endl;
}
int main() {
test01();
cout << "-------------------" << endl;
test02();
cout << "-------------------" << endl;
test03();
system("pause");
return 0;
}
构造函数调用规则
默认情况下c++构造器至少给一个类添加3个函数
- 默认构造函数（无参，函数体为空）
- 默认析构函数（无参，函数体为空）
- 默认拷贝构造函数，对属性进行值拷贝
构造函数的调用规则如下 - 如果用户定义有参构造，c++不再提供默认无参构造，但还是会提供默认拷贝构造函数
- 如果用户提供拷贝构造函数，c++不会再提供其他构造函数
深拷贝和浅拷贝
浅拷贝：简单的赋值拷贝(编译器生成的拷贝构造函数中简单的=操作)
深拷贝：在堆区重新申请空间，进行拷贝工作
浅拷贝带来的问题：
堆区的内存重复释放
如下：
没有重写拷贝构造函数，成员属性中身高用指针，在构造函数中，通过new创建赋值，而析构函数默认执行，在程序结束后对身高指针指向的堆区释放，而栈区遵循先进后出的原则，p0先出，释放掉指针指向的堆区，而p再执行释放指针操作，则属于非法操作。
#include<iostream>
using namespace std;
//深拷贝和浅拷贝
class Person {
public:
int m_age;
int* m_Height;
Person() {
cout << "Person的无参构造" << endl;
}
Person( int age,int height) {
m_age = age;
m_Height = new int(height);
cout << "Person的有参构造" << endl;
}
~Person() {
//将堆区开辟的数据做释放操作
if (m_Height != NULL) {
delete m_Height;
m_Height = NULL;//直接指向空，防止野指针
}
cout << "Person的析构函数" << endl;
}
};
void test01() {
Person p(18,170);
cout << "年龄为：" << p.m_age << "身高为：" << *p.m_Height << endl;
Person p0 = Person(p);
cout << "年龄为：" << p0.m_age << "身高为：" << *p0.m_Height << endl;
}
int main() {
test01();
system("pause");
return 0;
}
改进方式，利用深拷贝解决浅拷贝问题
Person(const Person &p) {
cout << "Person的拷贝构造函数" << endl;
m_age = p.m_age;
//m_Height = p.m_Height; 编译器实现的，不行，是指针
//深拷贝问题
m_Height = new int(*p.m_Height);
}
总结：
如果属性有在堆区开辟的，一定要自己提供拷贝构造函数，否则的话，防止浅拷贝带来的问题
初始化列表
作用：c++提供了初始化列表语法，用来初始化属性
语法
构造函数（）：属性（属性值），属性（属性值），属性（属性值）...{
// 函数体
}
# include<iostream>
using namespace std;
class P {
public:
int m_A;
int m_B;
int m_C;
//传统初始化属性
/*P(int a, int b, int c){
m_A = a;
m_B = b;
m_C = c;
}*/
//初始化列表
P(int a, int b, int c):m_A(a),m_B(b),m_C(c) {
}
};
void test01() {
P p(10, 20, 30);
cout << p.m_A << endl;
cout << p.m_B << endl;
cout << p.m_C << endl;
}
int main() {
test01();
system("pause");
return 0;
}
类对象作为类成员
C++类中的成员允许是另一个类的对象，我们称该成员为：对象成员
当其他类的对象作为本类的成员：
- 在构造中，是先构造其他的，在构造本类的。
- 在析构中，是先析构本类，再析构他类。
静态成员
静态成员就是在成员变量和成员函数前加上static，称为静态成员
静态成员分为：
- 静态成员变量
- 所有对象共享同一份数据
- 在编译阶段分配内存
- 类内声明，类外初始化
- 静态成员函数
- 所有对象共享同一个函数
- 静态成员函数只能访问静态成员函数
静态成员变量的访问方式：
- 通过对象进行访问
- 通过类名进行访问
静态成员也是有访问权限的
静态成员变量示例
# include <iostream>
using namespace std;
//静态成员
class Person {
public:
static int a;//类内声明
private:
static int b;
};
int Person::a = 100;//类外初始化
int Person::b = 200;
void test01() {
//共享同一份数据
Person p;
cout << p.a << endl;//100
Person p0;
p0.a = 300;
cout << p.a << endl;//300
}
void test02() {
Person p;
cout << p.a << endl;
cout << Person::a << endl;
//cout << Person::b << endl; //静态成员变量也是具有访问权限的
}
int main() {
//test01();
cout << "--------------" << endl;
test02();
system("pause");
return 0;
}
静态成员函数示例
# include<iostream>
using namespace std;
class Person {
public:
static void sayHello() {
//静态成员函数可以访问静态成员变量，不能访问非静态成员变量
m_A = 300;
//m_B = 200; //报错,无法区分是哪个对象的m_B
cout << "你好呀！！" << endl;
}
static int m_A;
int m_B;
private:
static void sayNothing() {
cout << "啥事都没有呀" << endl;
}
};
int Person::m_A = 200;
void test01() {
//两种调用方式：1.通过对象，2.通过类
Person p;
p.sayHello();
Person::sayHello();
//Person::sayNothing(); //静态成员函数也是具有访问权限的
}
int main() {
test01();
system("pause");
return 0;
}
析构函数
主要作用在于对象销毁前由系统自动调用，执行一些清理工作
语法
~类名（）{}
- 析构函数也没有返回值，也不需要写void
- 函数名称和类名相同，只需在类名前面加上一个~
- 析构函数不能有参数，因此不能发生重载
- 程序在对象销毁前会自动调用析构，无需手动调用，而且只会调用一次
扫一扫
464
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
