C++基础性问题（9.4）

1.static的用法
 

1.1修饰静态局部变量

在函数内部声明为 static 的变量只会被初始化一次，并且保持其值直到程序结束。每次调用函数时，这些变量的值都会保留。

静态局部变量存储在程序的静态存储区，而不是在栈上。这有助于保持其值

void counter() {
    static int count = 0;  // 只会初始化一次
    count++;
    std::cout << "Count: " << count << std::endl;
}

int main() {
    counter();  // 输出 Count: 1
    counter();  // 输出 Count: 2
    counter();  // 输出 Count: 3
    return 0;
}

1.2修饰静态成员变量 

1.属于整个类，而不是某个特定对象。它们在类的所有实例中共享（存储在类的静态存储区，而不是对象的实例中）。

2.初始化：可在类内进行声明，但必须在类外初始化 ，并且只初始化一次

//初始化
class MyClass {
public:
    static int staticVar;  // 声明静态成员变量
};

int MyClass::staticVar = 0;  // 定义并初始化静态成员变量

3.访问方式：静态成员变量可以通过类名直接访问，也可以通过对象访问，但通常推荐使用类名，以明确其是静态的。

MyClass::staticVar = 10;  // 通过类名访问
MyClass obj;
obj.staticVar = 20;      // 通过对象访问，实际也修改了静态成员

4.访问权限：静态成员变量的访问权限取决于其访问修饰符（public、protected、private），但它们的作用域和存储方式都是全局共享的。
 

class MyClass {
private:
    static int privateStaticVar;  // 私有静态成员变量
public:
    static void setPrivateVar(int value) {
        privateStaticVar = value;
    }
    static int getPrivateVar() {
        return privateStaticVar;
    }
};

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

1.3静态成员函数：

1.静态成员函数属于整个类，而不是某个对象。

2.它们不能访问类的非静态成员。

原因：

        ①不依赖于实例：静态成员函数属于整个类而非特定的对象实例。因此，它们没有 this 指针，也就没有办法知道具体哪个对象的非静态成员变量应该被访问。

        ②无对象上下文：非静态成员变量是对象的属性，每个对象都有自己的这些变量的副本。而静态成员函数在类级别上操作，不依赖于任何具体对象，所以它没有对象上下文来决定访问哪个实例的非静态成员。

        ③类与对象的分离：静态成员函数的设计目的是提供与对象状态无关的功能。它们只能操作与类本身相关的静态数据或功能，确保功能的通用性和一致性。

//如果静态成员函数需要操作非静态成员，通常需要通过对象实例来完成

class MyClass {
private:
    int nonStaticVar;
public:
    static void accessNonStaticVar(MyClass& obj) {
        // 通过对象访问非静态成员变量
        std::cout << obj.nonStaticVar << std::endl;
    }
};

3.访问静态成员函数：

class MyClass {
public:
    static void staticFunc() {
        // 只能访问静态成员变量或其他静态成员函数
    }
};

MyClass::staticFunc();  // 通过类名调用
MyClass obj;
obj.staticFunc();      // 也可以通过对象调用

4.用于工具函数：静态成员函数通常用于类内的工具函数，这些函数与类的对象状态无关，但需要与类的静态数据或其他静态函数交互。

class MyClass {
private:
    static int staticVar;
public:
    static void setStaticVar(int value) {
        staticVar = value;  // 可以访问静态成员变量
    }
    static int getStaticVar() {
        return staticVar;  // 可以访问静态成员变量
    }
};

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

总结：静态成员函数非常适合于那些不依赖于对象状态的功能，例如实现单例模式中的静态访问点或用于访问和操作类级别的数据。

1.4静态全局变量和函数：

特性：
1.文件作用域：静态全局变量只能在声明它的文件中访问。它不会被其他文件所见，防止了命名冲突。
 

2.链接性：static 全局变量具有内部链接（internal linkage），意味着它不会被链接到其他文件中。此特性有助于隐藏实现细节，只对定义它的文件可见。

3.生命周期：static 修饰的全局变量在程序运行期间的整个生命周期中存在，从程序开始到结束。这使得它在整个程序执行过程中保持其状态。

总结：主要用于减少命名冲突和增加代码的封装性，同时确保全局变量不会被无意间修改。

static int globalVar = 10;

static void helperFunction() {
    // Only visible in this file
}

_____________________________________________________________________________

2.const的用法 

2.1常量变量：定义不能改变的值。(√)

const int maxSize = 100;

2.2常量指针：能修改指针的指向,不改变对象值

//const 在*左边

int const * p =&a;
const int *p = &a;

2.3指针常量：变值   不变指向

 // * const
int *const p  = &a;

2.4指向常量的常量指针：指针地址和指向的数据都不可修改。

const int* const ptr = &maxSize; // 指针和数据都不可修改

2.5常量成员函数：成员函数声明为 const 时，保证不修改类成员变量
 

class MyClass {
public:
    void show() const { /* 不修改成员变量 */ }
private:
    int value;
};

 

__________________________________________________________________________________________________________________________________________

3.指针和引用的区别

指针：

1. 定义初始化：
   指针是一个变量，存储另一个变量的地址。
   可以初始化为 nullptr 或指向任意合法的地址。
   可以在程序运行时重新指向不同的地址。
2. 可为空
3. 语法操作：
   ①可*p解引用 ②&p取地址 ③进行算数运算
4. 需要检查是否为空
5. 可重新赋值，使其指向另一个变量或对象
6. 常见用法：
   用于动态内存分配。
   用于实现数据结构（如链表、树）。
   用于函数之间的复杂数据传递，特别是需要修改传递参数的情况。

引用：

1. 定义初始化：
   引用是一个别名，必须在定义时初始化，并且一旦绑定到一个变量，就不能再绑定到其他变量。
   不能被重新赋值以引用另一个变量。
2. 不可为空
3. 语法操作：
   直接使用如同原变量         不可进行算术运算
4. 不用检查是否为空，因为必须得初始化，且不能为空
5. 不能重新绑定到其他变量
6. 常见用法：
   用于实现函数的参数传递，特别是希望避免拷贝开销时。
   用于操作重载（如流插入操作符 << 和提取操作符 >>）。
   用于类成员函数，确保在类的成员函数中不修改对象状态时使用 const 引用。

 

4.谈一谈你对面向对象的理解

(解释)

通过将程序视为一组相互作用的对象来构建系统。每个对象都封装了数据和操作数据的方法

其中包含：
        对象：是类的实例，具有属性和方法

        类：创建对象的模板，定义了属性和方法

        封装：将数据和操作数据的代码打包到一个单独的单元（类）中，并隐藏其内部实现细节。只能通过类提供的公共方法来访问和修改，从而保护数据的完整性。

        继承：允许一个类继承另一个类的属性和方法。使得新类可以复用现有类的功能，同时还可以添加或重写特定功能。

        
        多态：指不同的对象可以通过相同的接口（方法名）以不同的方式响应。
                   多态可以通过方法重载（同一方法名不同参数）和方法重写（子类重写父类的方法）来实现。
                   多态使得程序能够以统一的方式处理不同类型的对象，提高了代码的灵活性和扩展性。
        抽象：是指从复杂系统中提取出核心特征和行为，并忽略不相关的细节。

                   通过定义抽象类（不能实例化的类）和接口（仅定义方法签名）来实现

（优势）

模块化：

• 通过将相关的数据和操作封装到对象中，OOP 使得系统更加模块化，每个模块（类）可以独立开发、测试和维护。

重用性：

• 继承和组合允许在不同上下文中重用现有的类和功能，减少了重复代码，提高了开发效率。

可维护性：

• 由于封装和良好的类设计，系统的内部实现与外部接口分离，使得系统更容易修改和扩展而不影响其他部分。

灵活性：

• 多态性允许对象通过相同的接口实现不同的行为，使得系统在面对变化时更加灵活和适应性强。

理解和设计：

• 通过模拟现实世界的对象及其交互，OOP 更符合人类的思维方式，易于理解和设计复杂系统。