美文网首页
C++入门08 --静态成员,单例模式,const成员,引用成员

C++入门08 --静态成员,单例模式,const成员,引用成员

作者: YanZi_33 | 来源:发表于2021-08-13 21:24 被阅读0次

    静态成员

    • 静态成员:被static关键字修饰的成员变量或者函数;
    • 可以通过对象(对象.静态成员)对象指针(对象指针->静态成员)类访问(类名::静态成员)
    • 静态成员变量:
      • 存储在数据段(全局区,类似于全局变量),整个程序运行过程中只有一份内存,不会占用实例对象的内存空间;
      • 对比全局变量,它可以设置访问权限,达到局部共享的目的;
      • 必须初始化,必须在类外面初始化,初始化时不能带static,如果类的声明与实现分离,在.cpp文件中初始化;
    #include <iostream>
    
    using namespace::std;
    
    class Car {
    public:
        static int m_price;
        void run(){
            cout << "run()" << endl;
        }
    };
    
    //初始化静态成员变量
    int Car::m_price = 0;
    
    int main(int argc, const char * argv[]) {
        
        Car car1;
        //通过对象访问
        car1.m_price = 10;
        
        Car car2;
        car2.m_price = 20;
        
        //通过类名访问
        cout << car2.m_price << endl;
        Car::m_price = 30;
        cout << car2.m_price << endl;
        
        //通过指针访问
        Car *p = new Car();
        cout << p->m_price << endl;
        
        return 0;
    }
    
    • 静态成员函数:
      • 内部不能使用this指针,this指针只能用在非静态函数的内部;
      • 不能是虚函数,虚函数只能是非静态成员函数;
      • 内部不能访问非静态成员变量/函数,只能访问静态成员变量/函数;
      • 非静态成员函数内部可以访问静态成员变量/函数;
      • 构造函数与析构函数不能是静态函数,因为构造函数与析构函数需要访问非静态成员变量;
      • 当声明与实现分离的时候,实现部分不能带static关键字;
    #include <iostream>
    
    using namespace::std;
    
    class Car {
    private:g
        //用来记录实例对象的个数
        static int m_count;
    public:
        static int m_price;
        
        Car(){
            m_count++;
        }
        
        ~Car(){
            m_count--;
        }
        
        void run(){
            cout << "run()" << endl;
        }
        
        static int getCount(){
            return m_count;
        }
    };
    
    //初始化静态成员变量
    int Car::m_price = 0;
    int Car::m_count = 0;
    
    int main(int argc, const char * argv[]) {
        
        Car car1;
        //通过对象访问静态成员变量
        car1.m_price = 10;
        
        Car car2;
        car2.m_price = 20;
        
        //通过类名访问静态成员变量
        cout << car2.m_price << endl;
        Car::m_price = 30;
        cout << car2.m_price << endl;
        
        //通过指针访问静态成员变量
        Car *p = new Car();
        cout << p->m_price << endl;
        
        //通过指针,类名,实例对象 调用静态成员函数
        cout << p->getCount() << endl;
        cout << Car::getCount() << endl;
        cout << car1.getCount() << endl;
        
        return 0;
    }
    

    单例模式

    • 在程序运行过程中,可能会希望某些类的实例对象永远只有一个;
    • 如何创建一个单例对象:
      • 把构造函数私有化;
      • 定义一个私有的静态成员变量指针,用于指向单例对象;
      • 提供一个公共的返回单例对象的静态成员函数;
    #include <iostream>
    
    using namespace::std;
    
    class Rocket {
    private:
        //静态成员变量
        static Rocket *ms_rocket;
        //构造函数私有
        Rocket(){ }
        //拷贝构造函数私有
        Rocket(const Rocket &rocket) { }
        //赋值私有
        void operator=(const Rocket &rocket){ }
        
    public:
        //静态成员函数
        static Rocket* sharedRocket(){
            if (ms_rocket == NULL) {
                ms_rocket = new Rocket();
            }
            return ms_rocket;
        }
        
        static void deleteRocket(){
            if (ms_rocket == NULL) return;
            delete ms_rocket;
            ms_rocket = NULL;
        }
    };
    
    //初始化静态成员变量
    Rocket* Rocket::ms_rocket = NULL;
    
    int main(int argc, const char * argv[]) {
        
        Rocket *r1 = Rocket::sharedRocket();
        Rocket *r2 = Rocket::sharedRocket();
        Rocket *r3 = Rocket::sharedRocket();
        
        cout << r1 << endl;
        cout << r2 << endl;
        cout << r3 << endl;
        
        Rocket::deleteRocket();
        
        return 0;
    }
    

    const成员

    • const成员:被const修饰的成员变量,非静态成员函数;
    • const成员变量:
      • 必须初始化,类内部初始化,可以在声明的时候直接初始化赋值;
      • 非static的const成员变量还可以在初始化列表中初始化;
    • const成员函数(非静态):
      • const关键字写在参数列表的后面,函数的声明与实现都必须带上const;
      • 函数内部不能修改非static的成员变量;
      • 函数内部只能调用const成员函数与static成员函数;
      • 非const成员函数可以调用const成员函数;
      • const成员函数与非const成员函数构成函数重载;
      • 非const对象(指针) 优先调用非const成员函数;
      • const对象(指针)只能用const成员函数;
    #include <iostream>
    
    using namespace::std;
    
    class Car {
    public:
        int m_price;
        //静态 const成员 不得修改且只有一份内存;
        static const int m_wheelsCount = 4;
        //const成员 不得修改;
        const int m_hasBoli;
        //const成员在初始化列表中初始化;
        Car() : m_hasBoli(1){
            
        }
        
        static void test(){
            
        }
        //const成员函数
        void test1() const {
            test();
        }
        
        //test1函数 构成函数重载
        void test1() {
            test();
        }
    };
    
    int main(int argc, const char * argv[]) {
        
        Car car1;
        car1.m_price = 100;
        
        
        Car car2;
        car2.m_price = 500;
        car2.test1(); //调用 test1
        
        const Car car3;
        car3.test1();//调用const test1
        
        return 0;
    }
    

    引用类型成员

    • 引用类型成员变量必须初始化(不考虑static情况);
      • 在声明的时候直接初始化;
      • 通过初始化列表进行初始化;
    #include <iostream>
    
    using namespace::std;
    
    class Car {
    public:
        int m_age;
        int &m_price = m_age;
        
        Car(int &price) : m_price(price){
            
        }
    };
    
    int main(int argc, const char * argv[]) {
        
        return 0;
    }
    

    相关文章

      网友评论

          本文标题:C++入门08 --静态成员,单例模式,const成员,引用成员

          本文链接:https://www.haomeiwen.com/subject/pwzdbltx.html