01 静态成员变量和静态成员函数

#include <iostream>
#include <stdlib.h>
using namespace std;
const int maxn = 10;
class Person {
public:
    int ma;
    static int mage;//加入static就是静态成员变量,会共享数据
    //静态成员变量,在类内声明,在类外初始化
    static void func() {
        cout << "func调用" << endl;
        mage = 10;    
    }

    //普通成员函数既可以访问普通变量,也可以访问静态成员变量
    void myFunc() {
        ma = 10;
        mage = 10;
    }
private:
    static int m_other;
    static void func2();
};
int Person::m_other = 0;

int Person::mage = 0;
void test01() {

    //1.通过对象访问属性
    Person p1;
    p1.mage = 10;
    

    Person p2;
    p2.mage = 20;

    cout << "p1:" << p1.mage << endl;
    cout << "p2:" << p2.mage << endl;

    //2.通过类名访问属性
    cout << "通过类名访问Age:" << Person::mage << endl;
    //静态成员函数
    //不可以访问 普通成员变量
    //可以访问 静态成员变量
    p1.func();
    p2.func();
    Person::func();
    
    
    
}
int main() {
    test01();
    system("pause");
}

02 主席案例-单例模式

  • 利用static ChairMan * 提供接口
  • 将构造函数,拷贝构造函数等均设为私有,不向外界提供
  • 并且将要初始化的变量设置为静态变量
#include <iostream>
using namespace std;

//创建主席类
//需求 单例模式 为了创建类中的对象,并且保证只有一个对象实例
class ChairMan
{
    //构造函数私有化
private:
    ChairMan() {
        cout << "国家主席调用" << endl;
    }
    ChairMan(const ChairMan &c) {

    }
    static ChairMan * singleMan;
public:
    static ChairMan * getinstance() {
        return singleMan;
    }
    
};

ChairMan * ChairMan::singleMan = new ChairMan;

void test01() {
    /*ChairMan c1;
    ChairMan *c2 = new ChairMan;*/
    /*ChairMan * cm = ChairMan::singleMan;
    ChairMan * cm2 = ChairMan::singleMan;
    ChairMan::singleMan = NULL;*/ //防止随意修改 为了让类中只有一个实例
    
    ChairMan * cm1 = ChairMan::getinstance();
    ChairMan * cm2 = ChairMan::getinstance();
    if (cm1 == cm2) {
        cout << "cm1 与 cm2 相同" << endl;
    }
    else
    {
        cout << "cm1 与 cm2 不相同" << endl;
    }

}

int main() {
    //cout << "main调用" << endl;主席限于main调用
    test01();
    system("pause");
}

03 打印机-单例模式

#include <iostream>
#include <string>
using namespace std;

class Printer {
private:
    Printer() {
        m_count = 0;
    };
    Printer(const Printer &p) {
        
    }

    static Printer *singlePrinter;
    int m_count;
public:
    static Printer* getInstrance() {
        return singlePrinter;
    }

    void printText(string text) {
        cout << text << endl;
        m_count++;
        cout << m_count << endl;
    }
};

Printer * Printer::singlePrinter = new Printer;

void test01() {
    //拿到打印机
    Printer * printer = Printer::getInstrance();
    printer->printText("离职报告");
    printer->printText("入职报告");
    printer->printText("加薪报告");
    Printer * printer2 = Printer::getInstrance();
    printer2->printText("离职报告");
    printer2->printText("入职报告");
    printer2->printText("加薪报告");

}

int main() {
    test01();
    system("pause");
}


04 成员变量和成员函数分开存储

  1. 非静态成员变量,属于对象身上
  2. 非静态成员函数 不属于对象身上
  3. 静态成员变量 也不属于对象身上
  4. 静态成员函数 不属于对象
  5. 空类的大小为 1 每个实例的对象都有独一无二的地址 char维护这个地址
#include <iostream>
#include <string>
using namespace std;
//#pragma pack(1) //加上这句话是一个一个的对齐
class Person {
public:
    int m_a;//非静态成员变量,属于对象身上
    void func() {}; //非静态成员函数 不属于对象身上
    static int m_b;//静态成员变量 也不属于对象身上
    static void func2(){}//静态成员函数 不属于对象
    double m_c; //按照字节对齐计算
    char s[64];
};

//结论,非静态成员变量,才属于对象身上

void test01() {
    cout << "size of Person = " << sizeof(Person) << endl;
    //空类的大小为 1 每个实例的对象都有独一无二的地址 char维护这个地址
}

void test02() {
    //this指针指向被调用函数的成员函数所属的对象
    Person p1;
    p1.func();//编译器会偷偷 加入一个 this 指针 Person * this

}

int main() {
    test01();
    system("pause");
}

05 this指针的引用

  • 利用this指针的引用可以实现链式编程
#include <iostream>
#include <string>
using namespace std;
//this可以解决命名冲突
class Person {
public:
    Person(int age) {
        this->age = age;
    }
    void compareAge(Person &p) {
        if (this->age == p.age) {
            cout << "年龄相等" << endl;
        }

        else
        {
            cout << "年龄不相等" << endl;
        }
    }

    //年龄相加
    Person& PlusAge(Person &p) {
        this->age += p.age;
        return *this;//*this指向对象本体
    }
    int age;
};


void test01() {
    Person p1(10);
    cout << p1.age;
    Person p2(10);
    p1.compareAge(p2);
    p1.PlusAge(p2).PlusAge(p2).PlusAge(p2);//链式编程
    cout << "p1的年龄:" << p1.age << endl;

    
}

int main() {
    test01();
    system("pause");
}

06 空指针访问成员函数

  • 一般加this == nullptr的判定
#include <iostream>
#include <string>
using namespace std;

class Person {
public:
    int m_Age;//mAge;
    void show() {
        cout << "Personshow" << endl;
    }

    void showAge() {
        if (this == NULL) {
            return;
        }
        cout << "m_age" << m_Age <<  endl;
    }


};

void test01() {
    Person* p1 = NULL;
    p1->show();
    p1->showAge();

}


int main() {
    test01();
    system("pause");
}

07 const修饰成员函数

  1. 常函数不允许修改指针指向的值
  2. 就算是常函数 我还是要执意修改 需要加关键字mutable
  3. 常对象 不允许修改对象
  4. 常对象可以调用常函数,不可以调用普通成员函数
#include <iostream>
#include <string>
using namespace std;

class Person {
public:
    Person() {
        m_A = 0;
        m_B = 0;
    }

    void showInfo() const { //常函数不允许修改指针指向的值
        this->m_B = 100;
        //this->m_A = 100;
        cout << "m_A:" << this->m_A << endl;
        cout << "m_B:" << this->m_B << endl;

    }

    void show2() {

    }
    int m_A;
    mutable int m_B;//就算是常函数 我还是要执意修改
};

void test01() {
    Person p1;
    p1.showInfo();

    //常对象 不允许修改对象
    const Person p2;
    //p2.m_A = 100;
    cout << p2.m_A << endl;
    //p2.show2();//不兼容的类型限定符 可以这样理解 就是函数内部你可能还会修改它
    //常对象可以调用常函数,不可以调用普通成员函数
    p2.showInfo();

}

int main() {
    test01();
    system("pause");
}

08 全局函数作友元函数

#include <iostream>
#include <string>
using namespace std;

class Room {
public:
    Room() {
        bedroom = "卧室";
        sittingroom = "客厅";
    }
private:
    string bedroom;
    string sittingroom;
    friend void goodGay(Room * room);//就是为了访问类中的私有属性
    
};


void goodGay(Room * room) {
    cout << "goodgay visits my" << room->bedroom << " and " << room->sittingroom << endl;
}

void test01() {
    Room *r = new Room;
    goodGay(r);
    
}

int main() {
    test01();
    system("pause");
}

09 类作友元函数

#include <iostream>
#include <string>
using namespace std;


class Building {
public:
    Building();
    string m_sittingRoom = "客厅";
private:
    friend class GoodGay;
    string m_bedRoom = "卧室";
};


class GoodGay {
public:
    GoodGay() {

    }

    void visit();
private:
    Building * building = new Building;

};

void GoodGay::visit()
{
    cout << "好朋友访问了" << building->m_sittingRoom << endl;
    cout << "好朋友访问了" << building->m_bedRoom << endl;
}

Building::Building()
{
    
}


void test01() {
    GoodGay gg;
    gg.visit();
}


int main() {
    test01();
    system("pause");
}
最后修改:2021 年 03 月 10 日 06 : 47 PM
如果觉得我的文章对你有用,请随意赞赏