列表初始化
#include<iostream>
#include<string>
using namespace std;
class Person{
public:
//初始化列表
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;
};
//手机类
class Phone{
public:
Phone(string name){
pName=name;
}
string pName;
};
//学生类
class Student{
public:
Student(string name,string pName):sName(name),sPhone(pName){//Phone phone = pName
}
string sName;
Phone sPhone;
};
int main(){
Person p(1,2,3);
cout<<p.m_C<<endl;
cout<<p.m_B<<endl;
cout<<p.m_A<<endl;
Student s("Curry", "vivo");//当其他类对象作为本类成员,先构造其他类对象,再构造自身
//析构和构造顺序相反
cout<<s.sName<<"拿着"<<s.sPhone.pName<<endl;
return 0;
}
类中this和const关键字
#include<iostream>
using namespace std;
class Person{
};
class Student{
int m_A;//非静态成员变量属于类的对象上
static int m_B;//静态不属于类的对象上
void func(){}//成员变量和成员函数分开存储,不属于类的对象上,静态也是
};
class Teacher{
public:
int age;
Teacher(int age){
this->age=age;//this关键字解决名称冲突
//this指针指向被调用成员函数所属对象
}
Teacher& PersonAddAge(Teacher &t){
this->age+=t.age;
return *this;//返回这个对象的本体
}
void show(){
if(this==NULL){//提高健壮性
return;
}
cout<<age<<endl;
}
};
class Man{
public:
Man(){
}
void showPerson() const{
//this指针本质是一个指针常量,指向不可修改,但是值可修改
//加上const表示值不可修改 如:m_A=100是在这个函数内是错误的
this->m_B=100;//特殊变量例外
}
int m_A;
mutable int m_B;//特殊变量
};
int main(){
Person p;
//空对象的存储空间为1,是为了区分空对象占内存的位置
cout<<sizeof(p)<<endl;
Student s;
cout<<sizeof(s)<<endl;//4
Teacher t(10);
cout<<t.age<<endl;
Teacher t2(20);
t2.PersonAddAge(t);
cout<<t2.age<<endl;
t2.PersonAddAge(t).PersonAddAge(t).PersonAddAge(t);//链式编程
cout<<t2.age<<endl;
//C++允许空指针访问成员函数
Teacher *pointer=NULL;
pointer->show();//空指针调用错误原因是因为age自带this指针,而调用的是空指针
const Man man;//在对象前加const变为常对象
//man.m_A=100; //不允许修改
man.m_B=200;//特殊变量允许修改
man.showPerson();//常对象只能调用常函数
return 0;
}
静态成员
#include<iostream>
using namespace std;
//静态成员变量
class Person{
public:
//所有对象都共享同一份数据
//编译阶段就分配内存
//类内声明,类外初始化
static int m_A;
int m_B;
//静态成员函数
static void func(){
cout<<"静态函数调用"<<endl;
m_A=100;
//m_B=200; //静态成员函数不可以访问非静态成员变量
}
};
int Person::m_A=100;
int main(){
Person p;
cout<<p.m_A<<endl;
Person p2;
p2.m_A=200;
cout<<p2.m_A<<endl;
//通过类名进行访问静态成员,注意如果权限是私有不可以访问
cout<<Person::m_A<<endl;
//1.通过对象访问静态成员方法
p.func();
//1.通过类名访问静态成员方法
Person::func();
//也是有访问权限的
return 0;
}
友元
//友元全局函数
#include<iostream>
#include<string>
using namespace std;
class Building{
//表明这个函数是这个类的好朋友,可以访问私有成员
friend void goodGay(Building *building);
public:
Building(){
m_SittingRoom="客厅";
m_BedRoom="卧室";
}
string m_SittingRoom;
private:
string m_BedRoom;
};
//全局函数
void goodGay(Building *building){
cout<<"全局函数在访问"<<building->m_SittingRoom<<endl;
cout<<"全局函数在访问"<<building->m_BedRoom<<endl;
}
int main(){
Building building;
goodGay(&building);
return 0;
}
//友元类
#include<iostream>
#include<string>
using namespace std;
class Building;
class Building{
fread class GoodGay;//是好朋友,可以访问私有成员
public:
Building();//换一种方式耍一下
string m_SittingRoom;
private:
string m_BedRoom;
};
//类外写成员函数
Building::Building(){
m_SittingRoom="客厅";
m_BedRoom="卧室";
}
//友元类
class GoodGay{
public:
GoodGay(){
building=new Building;
}
void visit();//参观函数,访问建筑类中的属性
Building *building;
};
void GoodGay::visit() {
cout<<"友元类在访问"<<building->m_SittingRoom<<endl;
cout<<"友元类在访问"<<building->m_BedRoom<<endl;
}
int main(){
GoodGay gg;
gg.visit();
return 0;
}
//友元成员函数
#include<iostream>
#include<string>
using namespace std;
class Building;
class GoodGay{
public:
GoodGay::GoodGay() {
building=new Building;
}
void visit();//可以访问建筑类中私有成员
void visit2();//不可以访问建筑类中私有成员
Building *building;
};
class Building{
friend void GoodGay::visit();//告诉编译器GoodGay下的成员函数visit可以作为本类好朋友
public:
Building(){
m_SittingRoom="客厅";
m_BedRoom="卧室";
}
string m_SittingRoom;
private:
string m_BedRoom;
};
void GoodGay::visit() {
cout<<building->m_SittingRoom<<endl;
cout<<building->m_BedRoom<<endl;
}
void GoodGay::visit2() {
cout<<building->m_SittingRoom<<endl;
//cout<<building->m_BedRoom<<endl;
}
int main(){
GoodGay gg;
gg.visit();
gg.visit2();
return 0;
}