C++对象特性： 静态成员
在 C++ 中，对象的特性包括静态成员、普通成员、构造函数、析构函数等。静态成员是类的一部分，对该类的所有对象来说是共享的。在使用静态成员时，需要注意以下几个特点和使用方式：
- 静态数据成员：
- 静态数据成员属于类本身，而不是类的各个对象。所有该类的对象共享同一个静态数据成员。
- 静态数据成员必须在类外部初始化定义。在类体内声明为静态，并在类外部初始化，示例：
int MyClass::staticVariable = 0;
- 静态成员函数：
- 静态成员函数不与特定的对象相关联，它们可以被直接调用，无需创建对象。
- 静态成员函数内部不能访问非静态成员函数或非静态数据成员（除非通过对象）。
下面是一些关于静态成员的使用情况和示例：
- 静态数据成员示例：
#include <iostream> using namespace std; class MyClass { public: static int staticVariable; }; int MyClass::staticVariable = 10; // 初始化静态数据成员 int main() { MyClass obj1; MyClass obj2; cout << "Static variable value: " << MyClass::staticVariable << endl; // 10 MyClass::staticVariable = 20; cout << "Static variable value after modification: " << MyClass::staticVariable << endl; // 20 return 0; }
- 静态成员函数示例：
#include <iostream> using namespace std; class MyClass { public: static void staticFunction() { cout << "This is a static function." << endl; } }; int main() { MyClass::staticFunction(); // 直接调用静态成员函数，输出：This is a static function. return 0; }
通过使用静态成员，可以实现对整个类的数据共享和功能调用，提供了更灵活和有效的编程模式。
C++对象特性：成员变量和成员函数分开存储
在C++中，类的成员变量和成员函数在内存中是分开存储的。成员变量存储在各个对象的内存空间中，而成员函数则存储在一块共享的内存区域中。这意味着不同对象的成员变量是独立的，但是它们共享相同的成员函数。
下面我们通过几种情况来详细讲解成员变量和成员函数分开存储的情况，并提供相应的代码示例：
- 成员变量存储在各个对象的内存空间：
#include <iostream> using namespace std; class MyClass { public: int num; // 成员变量 void display() { cout << "Num: " << num << endl; } }; int main() { MyClass obj1; MyClass obj2; obj1.num = 10; obj2.num = 20; obj1.display(); // 输出：Num: 10 obj2.display(); // 输出：Num: 20 return 0; s
在上面的示例中，每个对象obj1和obj2都有自己独立的num成员变量，它们分别存储在各自的内存空间中。
- 成员函数存储在共享的内存区域中：
#include <iostream> using namespace std; class MyClass { public: void display() { cout << "Display function called." << endl; } }; int main() { MyClass obj1; MyClass obj2; obj1.display(); // 输出：Display function called. obj2.display(); // 输出：Display function called. return 0; }
在上面的示例中，display()成员函数是共享的，无论是obj1还是obj2都调用的是同一个display()函数。
C++中的成员变量和成员函数分开存储，这种设计使得对象有独立的状态但共享相同的行为。
C++对象特性：this指针
在C++中，每个对象都有一个特殊的指针称为this指针，它指向调用该成员函数的对象。this指针可以在类的成员函数中使用，帮助区分不同对象的数据成员。下面讲解几种情况并提供相应的代码示例：
- 访问成员变量和成员函数：
#include <iostream> using namespace std; class MyClass { public: int num; void setNum(int n) { this->num = n; // 使用this指针明确指定要操作的对象的成员变量 } void display() { cout << "Num: " << this->num << endl; // 使用this指针访问成员变量 } }; int main() { MyClass obj1; MyClass obj2; obj1.setNum(10); obj2.setNum(20); obj1.display(); // 输出：Num: 10 obj2.display(); // 输出：Num: 20 return 0; }
在上面的示例中，通过this指针可以明确指定要操作的对象的成员变量。this指针指向调用成员函数的对象，使得可以在成员函数内部访问对象的数据成员。
- 返回对象本身：
#include <iostream> using namespace std; class MyClass { public: int num; MyClass* getThis() { return this; // 返回调用该函数的对象本身 } void display() { cout << "Num: " << this->num << endl; } }; int main() { MyClass obj; obj.num = 100; MyClass* ptr = obj.getThis(); ptr->display(); // 输出：Num: 100 return 0; }
上面的示例中，getThis()函数返回调用它的对象的指针，从而可以直接访问该对象的成员函数。
this指针在C++中是隐式的，不需要手动声明或传递，编译器会自动生成。通过使用this指针，可以更便捷地操作对象的数据成员和函数。
C++对象特性：空指针
在确认它有支付能力前，不要让它有消费的行为
在C++中，空指针是指不指向任何内存地址的指针。使用空指针时需要格外小心，以避免出现未定义行为。以下是关于空指针的几种情况和相应的示例：
- 使用空指针访问成员函数：
#include <iostream> using namespace std; class MyClass { public: void display() { cout << "Display function called." << endl; } }; int main() { MyClass* ptr = nullptr; // 初始化为空指针 if (ptr != nullptr) { ptr->display(); // 使用空指针调用成员函数 } else { cout << "Error: Trying to call member function on a null pointer." << endl; } return 0; }
在上面的示例中，我们初始化了一个空指针ptr，然后尝试使用空指针调用成员函数display()，由于空指针没有实际对象，可能会导致未定义行为。
- 空指针作为函数参数：
#include <iostream> using namespace std; void processPointer(int* ptr) { if (ptr != nullptr) { cout << "Pointer value: " << *ptr << endl; } else { cout << "Error: Null pointer passed as argument." << endl; } } int main() { int* ptr = nullptr; // 初始化为空指针 // 将空指针作为参数传递给函数 processPointer(ptr); return 0; }
在这个例子中，我们将空指针ptr作为参数传递给函数processPointer()，在函数内部检查了空指针并进行了相应处理。
- 空指针作为返回值：
#include <iostream> using namespace std; int* createInt(int value) { if (value > 0) { return new int(value); } else { return nullptr; } } int main() { int* ptr1 = createInt(10); // 返回非空指针 int* ptr2 = createInt(-1); // 返回空指针 if (ptr1) { cout << "Value in ptr1: " << *ptr1 << endl; delete ptr1; } if (ptr2 == nullptr) { cout << "Error: Failed to create integer pointer." << endl; } return 0; }
在上述示例中，createInt()函数根据传入的值动态创建一个int类型的指针，如果传入的值小于等于0，则返回空指针。在 main() 函数中，我们展示了使用返回的空指针的正确方式。
空指针在C++中可能会引发程序运行时错误，因此在使用时必须小心谨慎，确保对空指针进行了合适的检查。
C++对象特性：const修饰成员函数
当在C++中使用const修饰类的成员函数时，会有几种情况和对应的示例来展示不同的情况：
- 常量对象调用常量成员函数：
#include <iostream> using namespace std; class MyClass { public: void print() const { cout << "Const member function called." << endl; } void modify() { cout << "Non-const member function called." << endl; } }; int main() { const MyClass obj1; // 常量对象 obj1.print(); // 可以调用常量成员函数 // obj1.modify(); // 错误，常量对象不能调用非常量成员函数 return 0; }
在这个例子中，MyClass类定义了一个常量成员函数print()和一个非常量成员函数modify()。当创建一个常量对象obj1时，只能调用常量成员函数。
- 常量对象访问静态成员函数：
#include <iostream> using namespace std; class MyClass { public: static void staticFunction() { cout << "Static function called." << endl; } void nonStaticFunction() const { cout << "Non-static function called." << endl; } }; int main() { const MyClass obj; // 常量对象 MyClass::staticFunction(); // 可以直接调用静态成员函数 // obj.staticFunction(); // 错误，常量对象不能调用静态成员函数 obj.nonStaticFunction(); // 可以调用非静态成员函数 return 0; }
在上面的例子中，常量对象可以调用非静态成员函数，但不能调用静态成员函数。因为静态成员函数不属于特定对象，可直接通过类名访问。
- 返回常量对象或值：
#include <iostream> using namespace std; class MyClass { public: int getValue() const { return 10; } const char* getName() const { return "MyClass"; } }; int main() { const MyClass obj; // 常量对象 int value = obj.getValue(); // 调用常量成员函数返回常量值 const char* name = obj.getName(); // 调用常量成员函数返回常量指针 return 0; }
在这个例子中，常量成员函数可以返回常量对象或值，在调用时会保证不会改变对象的状态。
通过这些例子，我们展示了在C++中使用const修饰成员函数的几种常见情况。const可以帮助我们定义更加安全和符合逻辑的类，同时确保对象的状态不被意外修改。
