C++从入门到精通 (4) (适合C入门后C++进阶)连载!!-CSDN博客

class A
{
public:
    static int a;   //定义静态成员变量
};
int A::a = 10;   //静态成员变量 在类内声明 类外初始化

void test_01()
{
    A a;
    cout<<a.a<<endl;    //利用类对象访问   10
    cout<<A::a<<endl;   //利用类名访问    10
}

静态函数

成员函数前添加static关键字变为静态成员函数静态成员函数属于类静态成员函数只能调用静态成员变量。

class A
{
public:
    static int a;   //静态成员变量
    int b;
    static void func()  //静态成员函数
    {
        //cout<<b<<endl; //ERROR 静态成员函数只能调用静态成员变量
        cout<<a<<endl;  //静态成员函数打印静态成员变量
        cout<<"静态成员函数"<<endl;
    }
};

int A::a = 10;

void test_01()
{
    A::func();  //调用静态成员函数
}

const静态变量

静态变量是所有对象共享一个资源（共享的数据往往使用公共权限）

静态常量则是共享的数据不允许修改是一份固定且共享的数据

class A
{
public:
    const static int a = 10;    //静态常量
};

void test_01()
{
    cout<<A::a<<endl;   //10
}

单例

概述

单例就是静态成员的一个应用场景

概述每一次创建的类对象都是同一个对象；

好处:节约空间

应用

//单例应用:
class MySingle
{
private:    //1.构造函数，拷贝构造私有化
    static MySingle *sin;   //2.定义静态的属性，外部进行初始化
    MySingle()
    {}
    MySingle(const MySingle &ob)
    {}
public:
    static MySingle* getSingle()    //3.调用静态函数，返回静态对象的值
    {
        return sin;
    }
};

MySingle* MySingle::sin = new MySingle; //外部进行初始化

void test_01()
{
    MySingle *s1 = MySingle::getSingle();
    MySingle *s2 = MySingle::getSingle();
    cout<<s1<<endl; //地址相同
    cout<<s2<<endl;
}

内存空间与this(重点)

内存空间

主要分析类中数据是否占用内存空间（占多大空间）

class A
{
public:
};

void test_01()
{
    cout<<sizeof(A)<<endl;  //1
}
//定义空类 占用一个字节(占位符)

class A
{
public:
    func()
    {};
};

void test_01()
{    
    cout<<sizeof(A)<<endl;  //1
}
//成员函数不占用空间

class A
{
public:
    static int a;
};

void test_01()
{
    cout<<sizeof(A)<<endl;  //1
}
//静态成员变量不占用空间

class A
{
public:
    static func()
    {}
};

void test_01()
{
    cout<<sizeof(A)<<endl;  //1
}
//静态成员函数不占用空间

class A
{
public:
    int a;
    int b;
};

void test_01()
{
    cout<<sizeof(A)<<endl;  //8
}
//普通静态成员占用自身大小个字节 int -- 4

成员函数不占用空间

静态成员变量不占用空间

静态成员函数不占用空间

普通静态成员占用自身大小个字节 int -- 4

this应用(重点)

this代表当前对象表示调用当前成员函数的对象

使用this 不怕类的成员变量和形参出现重名出现二义性现象了

class A
{
public:
    int a;
    A(int a)
    {
        this->a = a;    //出现重名变量  加上this标记a为类对象成员
    }                   //不添加this的变量 根据就近原则取值
};

void test_01()
{
    A a(10);
    cout<<a.a<<endl;    //10
}

this链式编程(重点)

在引用中,进行链式编程,通过引用对象进行重复调用有this可省略引用对象传参

class A
{
public:
    A& print(char* str)
    {
        cout<<str<<endl;
        return *this;
    }
};

void test_01()
{
    A a;
    a.print("hello").print("world").print("haha");
}

const修饰成员函数

当你不想在成员函数里对变量赋值可在成员函数后添加const

class A
{
public:
    int a;
    mutable int b;  //添加mutable后 可在const修饰的函数中赋值
    void func(int a,int b) const //在函数后添加了const不可在函数内对类成员变量赋值
    {
        //this->a = a;  //error
        this->b = b;
    }
};

void test_01()
{
     A a;
     a.func(10,20);
}

友元

成员属性一般是私有的如果需要特殊规则区域去使用私有成员则需要设置友元

例如:卧室是私有的但是特殊人群可以进入特殊人群设置友元即可

全局友元(重要)

友元的规则设置在全局函数中

class Room
{
    friend void showRoom(Room &r);  //添加友元
private:    
    string wosi;    //string:c++中的一个字符串类型
public:
    string keting;
    Room(string keting,string wosi)
    {
        this->keting = keting;
        this->wosi = wosi;
    }
};

void showRoom(Room &r)
{
    cout<<"访问:"<<r.keting<<" "<<r.wosi<<endl;   //使用友元前 error
}

成员友元

class Room;
class goodGay
{
public:
    string name;
    goodGay(string name)
    {
        this->name = name;
    }
    void showRoom(Room &r);
};

class Room
{
    friend void goodGay::showRoom(Room &r); //添加类函数为友元
private:
    string wosi;
public:
    string keting;
    Room(string wosi,string keting)
    {
        this->wosi = wosi;
        this->keting = keting;
    }
};

void goodGay::showRoom(Room &r)
{
    cout<<name<<"正在访问:"<<r.keting<<"  "<<r.wosi<<endl;
}

void test_01()
{
    Room r("卧室","客厅");
    goodGay g("老王");
    g.showRoom(r);
}

类友元

与成员友元类似，只需将成员友元注释，编写类友元即可

//friend void GoodGay::showData(Room &room);  //GoodGay类的showData函数是友元
friend class GoodGay;  //声明友元类  该类中的所有成员函数都可访问Room的私有属性

😀期待点赞订阅😀