从0开始C++（四）：作用域限定符、this指针、static与const关键字详解

目录

作用域限定符

this指针的使用方法

static关键字的使用方法

const关键字的使用方法

---

作用域限定符

C++中的作用域解析运算符(::)用于在全局作用域中引用局部作用域的变量或函数。它可以用于以下几种情况：

1、引用全局变量：如果在某个函数内部定义了与全局作用域中的变量同名的局部变量，可以使用作用域解析运算符来引用全局变量。

int x = 10; // 全局变量x

void func() {
    int x = 20; // 局部变量x
    cout << ::x << endl; // 引用全局变量x
}

2、引用嵌套命名空间中的变量或函数：如果在命名空间的内部定义了与外部命名空间同名的变量或函数，可以使用作用域解析运算符来引用外部命名空间中的变量或函数。

namespace A {
    int x = 10; // 命名空间A中的变量x
    void func() {
        cout << "A::func" << endl;
    }
}

namespace A::B {
    int x = 20; // 命名空间A::B中的变量x
    void func() {
        cout << "A::B::func" << endl;
    }
}

void func() {
    cout << "global func" << endl;
}

int main() {
    using namespace A::B;
    
    cout << A::x << endl; // 引用命名空间A中的变量x
    cout << A::B::x << endl; // 引用命名空间A::B中的变量x
    
    A::func(); // 调用命名空间A中的函数func
    A::B::func(); // 调用命名空间A::B中的函数func
    
    ::func(); // 调用全局函数func

    return 0;
}

3、引用类的静态成员：如果在类的内部定义了静态成员变量或静态成员函数，可以使用类名加上作用域解析运算符来引用类的静态成员。

class MyClass {
public:
    static int x; // 静态成员变量x

    static void func() { // 静态成员函数func
        cout << "MyClass::func" << endl;
    }
};

int MyClass::x = 10; // 静态成员变量初始化

int main() {
    cout << MyClass::x << endl; // 引用类的静态成员变量x
    MyClass::func(); // 调用类的静态成员函数func

    return 0;
}

通过使用作用域解析运算符，可以明确指定变量、函数或类的作用域，避免命名冲突和不必要的歧义。

this指针的使用方法

在C++中，this指针是一个特殊的指针，用于指向当前对象的指针。它可以在类的成员函数中使用，用于引用调用该成员函数的对象的地址。以下是this指针的使用方法：

1、在成员函数中使用this指针来引用对象的成员变量：

class MyClass {
public:
    int x;

    void setX(int val) {
        this->x = val; // 使用this指针引用对象的成员变量
    }
};

2、在成员函数中使用this指针来调用对象的其他成员函数：

class MyClass {
public:
    void func1() {
        // do something
    }

    void func2() {
        this->func1(); // 使用this指针调用对象的其他成员函数
    }
};

3、在类的构造函数和析构函数中使用this指针来初始化和释放对象的成员变量：

class MyClass {
public:
    int x;

    MyClass(int val) {
        this->x = val; // 使用this指针初始化成员变量
    }

    ~MyClass() {
        // do something
    }
};

4、在类的静态成员函数中不能使用this指针，因为静态成员函数不依赖于具体的对象。

使用this指针可以明确指示当前对象的地址，可以解决对象之间的命名冲突问题，同时也方便了对对象的成员变量和成员函数的操作。

static关键字的使用方法

在C++中，static关键字有多种使用方法，具体取决于其所应用的上下文。以下是几种常见的用法：

1、静态成员变量：

class MyClass {
public:
    static int x;
};

int MyClass::x = 0; // 初始化静态成员变量

int main() {
    MyClass obj1;
    obj1.x = 10; // 使用对象访问静态成员变量
    cout << obj1.x << endl; // 输出: 10

    MyClass obj2;
    cout << obj2.x << endl; // 输出: 10 (静态成员变量对所有对象共享)
}

静态成员变量是属于类而不是对象的，它对所有类的对象都是共享的。因此，可以通过类名或对象来访问静态成员变量。

2、静态成员函数：

class MyClass {
public:
    static void func() {
        // do something
    }
};

int main() {
    MyClass::func(); // 使用类名调用静态成员函数
}

静态成员函数没有this指针，因为它不依赖于任何对象。因此，它只能访问静态成员变量和调用其他静态成员函数。

3、静态局部变量：

void func() {
    static int x = 0; // 静态局部变量 (只初始化一次)
    x++;
    cout << x << endl;
}

int main() {
    func(); // 输出: 1
    func(); // 输出: 2
    func(); // 输出: 3
}

静态局部变量在函数第一次调用时初始化，然后保留其值，直到程序结束。它在函数调用之间保持存在，并且可以在函数调用之间保持其值。

4、静态类：

class MyClass {
public:
    // 类的成员函数和成员变量

    static MyClass createObject() {
        MyClass obj;
        // 对象的初始化
        return obj;
    }
};

int main() {
    MyClass obj = MyClass::createObject(); // 使用静态类成员函数创建对象
}

静态类成员函数可以用于创建和返回类的对象，而无需创建类的实例。这种方式使得创建对象更加灵活和方便。

const关键字的使用方法

在C++中，const关键字用于声明一个常量。const可以应用于变量、函数参数、函数返回值等。以下是一些常见的const关键字的使用方法：

1、声明常量变量：

const int x = 5; // 声明一个常量整数变量
const double PI = 3.1415926; // 声明一个常量浮点数变量

常量变量的值在声明后不能被修改。

2、声明常量引用：

int number = 10;
const int& ref = number; // 声明一个常量引用

ref = 5; // 错误，不能修改常量引用所引用的值
number = 5; // 正确，可以修改变量的值

常量引用可以指向非常量对象，但不能通过引用修改对象的值。

3、函数参数为常量：

void printNumber(const int num) {
    // num = 10; // 错误，不能修改函数参数的值
    cout << num << endl;
}

通过将函数参数声明为const，可以确保函数内部不会修改参数的值。

4、返回常量值的函数：

const int getNumber() {
    return 5;
}

int main() {
    int number = getNumber(); // 常量值可以赋值给非常量变量
    return 0;
}

通过将函数返回类型声明为const，可以确保返回的值不会被修改。

5、常量成员函数：

class MyClass {
public:
    void print() const {
        // do something
    }
};

int main() {
    const MyClass obj;
    obj.print(); // 常量对象只能调用常量成员函数
}

通过在成员函数后面添加const修饰符，可以声明该成员函数不会修改对象的状态。

总之，const关键字用于声明常量，可以应用于变量、引用、函数参数和函数返回值等。通过使用const，可以增加代码的可读性和安全性，防止意外修改常量或对象的值。