一、类的定义
class 类名
{
//访问修饰符://public或protected或private
//成员变量和成员方法
};
二、访问权限:
public,公有,类内类外均可访问,可继承
protected,保护,类内可访问,类外不可访问,可继承。
private,私有,类内可访问,类外不可访问,不可继承。(实际上子类的对象仍会开辟父类私有成员变量的内存,但被隐藏了,不可访问操作)
与struct不同,若不声明权限,类中成员默认为私有private成员。
三、构造函数和析构函数
(若未提供构造和析构,编译器会提供编译器提供的构造函数和析构函数,是空实现)
构造函数:主要作用在于创建对象时为对象的成员属性赋值
构造函数与析构函数语法:
构造函数语法:类名(){}
1.构造函数,没有返回值也不写void
2.函数名称与类名相同
3.构造函数可以有参数,因此可以发生重载
4.程序在调用对象时候会自动调用构造,无须手动调用,而且只会调用一次
按参数分为:有参构造和无参构造
按类型分为:普通构造和拷贝构造
拷贝构造函数的参数一定要是:const 类名 &对象名。比如:Person(const Person &p1)
析构函数语法:~类名(){}
1.析构函数,没有返回值也不写void
2.函数名称与类名相同,在名称前加上符号~
3.析构函数不可以有参数,因此不可以发生重载
4.程序在对象销毁前会自动调用析构,无须手动调用,而且只会调用一次
调用:
(匿名对象 特点:当前行执行结束后,系统会立即回收掉匿名对象)
注意1:调用默认构造函数的时候不要加(),否则编译器会认为是一个函数的声明Person pl();
注意2:不要利用拷贝构造函数 初始化匿名对象 编译器会认为Person(p3) == = Person p3; 对象声明
class Person
{
public:
Person()
{
cout << "默认构造函数调用" << endl;
}
Person(int a)
{
cout << "有参构造函数调用" << endl;
}
Person(const Person &p)
{
cout << "拷贝构造函数调用" << endl;
}
int a;
};
void test()
{
//1、括号法
Person pl; //默认构造函数调用
Person p2(10); //有参构造函数
Person p3(p2); //拷贝构造函数
//注意1:调用默认构造函数的时候不要加(),
//否则编译器会认为是一个函数的声明Person pl()
//2、显示法
Person pl;
Person p2 = Person(10); //有参构造
Person p3 = Person(p2); //拷贝构造
//Person(10); //匿名对象 特点:当前行执行结束后,系统会立即回收掉匿名对象
//注意2:不要利用拷贝构造函数 初始化匿名对象
//编译器会认为Person(p3) == = Person p3; 对象声明
//3、隐式转换法
Person p4 = 10; //相当于写了Person p4=Person(10); 有参构造
Person p5 = p4; //拷贝构造
}
int main()
{
test();
return 0;
}
拷贝构造函数的调用时机
1、使用一个已经创建完毕的对象来初始化一个新对象
2、值传递的方式给函数参数传值
3、值方式返回局部对象
class Person
{
public:
Person()
{
cout << "默认构造函数调用" << endl;
}
Person(int a)
{
cout << "有参构造函数调用" << endl;
}
Person(const Person &p)
{
cout << "拷贝构造函数调用" << endl;
}
int a;
};
void test1()
{
//1、使用一个已经创建完毕的对象来初始化一个新对象
Person p1(20);
Person p2(p1);
}
//2、值传递的方式给函数参数传值
void doWork1(Person p)
{
}
void test2()
{
Person p1;
doWork1(p1);
}
//3、值方式返回局部对象
Person doWork2()
{
Person p;
return p;
}
void test3()
{
doWork2();
}
int main()
{
test1();
test2();
test3();
return 0;
}
调用规则:
默认情况下,C++编译留至少给一个类添加3个函数
1.默认构造函数(无参,函数体为空)
2.默认析构函数(无参,函数体为空)
3.默认拷贝构造函数,对属性进行值拷贝
构造函数调用规则如下:
如果用户定义有参构造函数,c++不在提供默认无参构造,但是会提供默认拷贝构造。如果用户定义拷贝构造函数,c++不会再提供其他构造函数
深拷贝与浅拷贝:
浅拷贝:简单的赋值拷贝操作
深拷贝:在堆区重新申请空间,进行拷贝操作
class Person
{
public:
Person(int Height)
{
cout << "有参构造函数调用" << endl;
m_Heigh = new int(Height);
}
Person(const Person &p)
{
this->m_Heigh = new int(*p.m_Heigh);
//深拷贝,重新申请内存空间,避免释放的时候重复释放,报错
//浅拷贝,编译器默认的拷贝函数执行简单的赋值操作this->m_Heigh = p.m_Heigh;
}
~Person()
{
if (m_Heigh != NULL)
{
delete m_Heigh;
m_Heigh = NULL;
}
}
private:
int *m_Heigh;
};
void test()
{
Person p1(175);
Person p2(p1);
}
int main()
{
test();
return 0;
}
初始化列表:
语法:构造的数():属性1(值1),属性2(值2)...{}
class Phone
{
public:
Phone()
{
cout << "Phone 默认构造函数调用" << endl;
}
Phone(string pName)
{
cout << "Phone有参构造函数调用" << endl;
m_pName = pName;
}
~Phone()
{
cout << "Phone析构函数调用" << endl;
}
private:
string m_pName;
};
class Person
{
public:
Person(string pName):m_Phone(pName)
//相当于Phone m_Phone=pName;且不需要调用Phone默认构造函数
{
cout << "Person构造函数调用" << endl;
}
~Person()
{
cout << "Person析构函数调用" << endl;
}
private:
Phone m_Phone;
};
void test()
{
Person p("IPhoneX");
}
int main()
{
test();
return 0;
}
四、对象作为类成员:
当类中成员是其他类对象时,我们称该成员为对象成员
构造的顺序是:先调用对象成员的构造,再调用本类构适
析构顺序与构造相反
析构函数:主要作用在于对象销毁前系统自动调用,执行一些清理工作。
五、静态成员:
静态成员就是在成员变量和成员函数前加上关键字static,称为静态成员静志成员分为:
(1)静态成员变量
所有对象共享同一份数据
在编译阶段分配内存
类内声明,类外初始化
(2)静志成员函数
所有对象共享同一个函数
静态成员函数只能访问静态成员变量
(3)静态成员的2种访问方式:
a, 通过对象访问。b, 通过类名进行访问(注意:静态成员变量也有访问权限,私有权限类外无法访问)
class Person
{
public:
static int m_A;
};
int Person:: m_A= 20; //初始化类的静态成员变量
void test()
{
//1、通过对象访问
Person p;
cout << p.m_A << endl;
//2、通过类名访问
cout << Person::m_A << endl;
}
int main()
{
test();
return 0;
}
六、内存模型:
空对象占用1个字节空间,是为了区分空对象占内存位置。
非静态成员变量 属于类的对象上
静态成员变量 不属于类对象上
非静态成员函数 不属于类对象上
静态成员函数 不属于类的对象上
七、this指针:
(this指针的本质是个指针常量,指向不可修改)
this指针的用途:
当形参和成员变量同名时,可用this指针来区分
在类的非静态成员函数中返回对象本身,可使用return *this
class Person
{
public:
Person &add(Person &p) //引用,输出结果为80 80
//Person add(Person &p) //赋值一个新对象,输出结果为60 20
{
this->m_A += p.m_A;
return *this;
}
int m_A;
};
void test()
{
Person p1;
p1.m_A = 10;
cout<<p1.add(p1).add(p1).add(p1).m_A<<endl;
cout << p1.m_A;
}
int main()
{
test();
return 0;
}
八、空指针访问成员函数
C++中空指针也是可以调用成员的数的,但是也要注意有没有用到this指针,
如果用到this指针,需要加以判断保证代码的健壮性。
如加入:if(this==NULL){return;}
九、const修饰成员函数
常函数:
成员函数后加const后我们称为这个的数为常函数
常函数内不可以修改成员属性
成员属性声明时加关键字mutable后,在常函数中依然可以修改
public:
//this指针的本质 是指针常量,指针的指向是不可以修改的Person *const this;
//在成员函数后面加const,修饰的是this指向,
//相当于const Person *const this;,让指针指向的值也不可以修改
void showPerson() const
{
this->m_A = 10;
}
mutable int m_A; //加上mutable,变成特殊变量,
//即使在常函数中,也可以修改这个值
};
this指针的本质 是指针常量,指针的指向是不可以修改的Person *const this;
在成员函数后面加const,修饰的是this指向,
相当于const Person *const this; 让指针指向的值也不可以修改
常对象:
声明对象前加const称该对象为常对象
常对象只能调用常函数(或调用mutable修饰的特殊变量)
十、友元friend
作用:让一个函数或者类 访问另一个类中私有成员
全局函数做友元
类做友元
成员函数做友元
十一、继承
语法:
class 子类 : 继承方式 父类
继承的好处:减少重复代码
继承方式:
public:
父类中公共成员 到子类中仍是公共成员
父类中保护成员 到子类中仍是公共成员
父类中私有成员,子类访问不到
pretected:
父类中公共成员 到子类中变为保护成员
父类中保护成员 到子类中仍是保护成员
父类中私有成员,子类访问不到
public:
父类中公共成员 到子类中变为私有成员
父类中保护成员 到子类中变为私有成员
父类中私有成员,子类访问不到
继承的对象模型
父类中所有非静态成员属性都会被子类继承下去
父类中私有成员属性 是被编译器给隐藏了,因此是访问不到,但是确实被继承下去了
继承中构造和析构顺序:
继承中 先调用父类构造函数,再调用子类构造函数,析构顺序与构造相反
继承同名成员处理:
访问子类同名成员 直接访问即可
访问父类同名成员 需要加作用域