C++特殊成员

参考书籍:

C++ Primer

Essential C++

编译器:

gcc / g++

C++特殊成员

const成员

• const修饰的数据成员

• 初始化必须采用初始化参数列表
• 不能被修改
• 构造函数必须要初始化常数据成员

• const修饰的成员函数

• 写法上要注意: const修饰是写在函数后面
• const成员函数不能修改任何的数据成员
• 如果实在是要在常成员函数中修改该数据，用mutable修饰数据成员即可
• 常成员函数可以普通函数同时存在

• const对象

• const修饰的对象
• 常对象只能调用常成员函数

#include <iostream>
using namespace std;
class MM {
   public:
    MM(int age) : name("小芳"), num(4323) {
        this->age = age; 
    }
    MM(string name, int age, int num) : name(name), age(age), num(num) {}
    // MM() {}   常数据必须要初始化，错误
    // MM() = default;   //正确，可以构造无参对象
    void print() {
        age = 18;
        // num = 11;    //不能修改常数据成员
        cout << this->name << " " << this->num << " " << this->age << endl;
        cout << "普通函数" << endl;
    }
    //常成员函数： const写在函数后面
    void print() const {
        cout << this->name << " " << this->num << " " << this->age << endl;
        cout << "常成员函数" << endl;
    }
    void printData() const {
        // age = 23;      //常成员函数，不能修改数据成员
        cout << this->name << this->num << this->age << endl;
    }
    void test() {}

   protected:
    //常数据成员
    const string name;
    const int num;
    int age;  // mutable 可修改的意思
};

int main(int argc, char** argv) {
    MM mm("小丽", 18, 1001);
    //如果普通函数和常成员函数同名
    mm.print();  //普通对象优先调用普通函数
    const MM object(18);
    object.print();  //常对象只能调用常成员函数
    object.printData();
    // object.test();
    // //错误，常对象只能调用常成员函数
    return 0;
}

static成员

static成员不属于某一个单独对象，是属于类的，通俗一点讲，是所有对象的共享的，static成员依然受权限

satic成员他的访问可以不需要对象(用类名限定的方式去访问)

• static数据成员

• 初始化必须在类外初始化
• 类实现的时候不需要用static修饰了

• static成员函数

• static写在修饰函数的前面
• 类外实现也不需要static修饰
• 静态函数中没有this指针
• 静态成员函数的访问问题

• 静态成员函数访问静态成员 是可以直接访问
• 静态成员函数访问非静态数据成员，必须通过指定对象的方式

• 静态成员函数传参
• 在静态成员函数定义对象去访问

#include <iostream>
#include <string>
using namespace std;
class User {
   public:
    User(string name = "默认") {
        this->count++;  //类中访问
        this->m_count++;
    }
    void print() {
        cout << name << " " << count << endl;
    }
    // void test() {}  不能和普通函数形参重载效果，会造成重定义问题
   public:
    static void test();
    static void testData(User& object);

   private:
    string name;

   public:
    static int count;
    int m_count = 0;
};
//必须在类外面做初始化，不需要static修饰了
int User::count = 0;
void User::test() {
    cout << "count:" << count << endl;
    // cout << "m_count:" << m_count << endl;
    // //静态成员函数中不能直接调用非静态成员
    cout << "静态函数" << endl;
}
void User::testData(User& object) {
    cout << object.m_count << endl;  //传参
    User mm;
    cout << mm.m_count << endl;  //创建对象
}

int main(int argc, char** argv) {
    cout << User::count << endl;  // static 成员访问不需要对象
    User object[3];
    cout << User::count << endl;
    User mm;
    cout << mm.count << endl;
    cout << User::count << endl;  //可以用类名访问，前提是权限没问题
    cout << mm.m_count << endl;  //不能用类名
    User::test();  //因为存在这种调用，所以静态成员函数中不能存在this指针
    mm.test();
    return 0;
}

顺便介绍一下多文件的写法(Google)

• 一个类一个模块

• 声明写在.h
• 实现写在.cpp
• 声明和试下写在一起 .hpp
• 头文件包含尽量在.cpp完成
• 设计项目时候，头文件形成交叉包含，说明思想有问题，自己重新设计代码
• 不要为了拆分而拆分

• 静态数据成员多文件写法