Day8-C++基础之对象拓展和友元

列表初始化

#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;
}