C++的类功能整合

1. 类的基本概念

类是面向对象编程的核心，它封装了数据和操作数据的函数。

#include <iostream>
using namespace std;class MyClass {
public:int publicData;void publicFunction() {cout << "Public function" << endl;}private:int privateData;void privateFunction() {cout << "Private function" << endl;}
};int main() {MyClass obj;obj.publicData = 10;obj.publicFunction();// obj.privateData = 20; // 错误：private成员无法直接访问// obj.privateFunction(); // 错误：private成员无法直接访问return 0;
}

2. 成员变量和成员函数

成员变量是类中的数据，成员函数是类中的函数。

#include <iostream>
using namespace std;class MyClass {
public:int data; // 成员变量void display() { // 成员函数cout << "Data: " << data << endl;}
};int main() {MyClass obj;obj.data = 42;obj.display(); // 输出: Data: 42return 0;
}

3. 访问修饰符

public：任何地方都可以访问。
private：只能类内部访问。

protected：类内部和派生类可以访问。

#include <iostream>
using namespace std;class MyClass {
public:int publicData;private:int privateData;protected:int protectedData;public:void display() {cout << "Public: " << publicData << endl;cout << "Private: " << privateData << endl;cout << "Protected: " << protectedData << endl;}
};int main() {MyClass obj;obj.publicData = 10;// obj.privateData = 20; // 错误：private成员无法直接访问// obj.protectedData = 30; // 错误：protected成员无法直接访问obj.display();return 0;
}

4. 构造函数和析构函数

构造函数在对象创建时调用，析构函数在对象销毁时调用。

#include <iostream>
using namespace std;class MyClass {
public:MyClass() {cout << "Constructor" << endl;}~MyClass() {cout << "Destructor" << endl;}
};int main() {MyClass obj; // 创建对象时调用构造函数// 程序结束时调用析构函数return 0;
}

5. 运算符重载

允许自定义运算符的行为。

#include <iostream>
using namespace std;class Complex {
public:double real, imag;Complex(double r, double i) : real(r), imag(i) {}Complex operator + (const Complex& other) {return Complex(real + other.real, imag + other.imag);}
};int main() {Complex c1(1.0, 2.0);Complex c2(3.0, 4.0);Complex c3 = c1 + c2;cout << "c3: " << c3.real << " + " << c3.imag << "i" << endl; // 输出: c3: 4 + 6ireturn 0;
}

6. 拷贝构造函数和赋值运算符

用于对象的拷贝和赋值。

#include <iostream>
using namespace std;class MyClass {
public:int data;MyClass(int d) : data(d) {}MyClass(const MyClass& other) : data(other.data) {cout << "Copy constructor" << endl;}MyClass& operator = (const MyClass& other) {if (this != &other) {data = other.data;}return *this;}
};int main() {MyClass obj1(42);MyClass obj2 = obj1; // 调用拷贝构造函数MyClass obj3(0);obj3 = obj1; // 调用赋值运算符cout << "obj2.data: " << obj2.data << endl; // 输出: obj2.data: 42cout << "obj3.data: " << obj3.data << endl; // 输出: obj3.data: 42return 0;
}

7. 模板类

允许类在编译时根据类型参数生成不同的类。

#include <iostream>
using namespace std;template <typename T>
class MyTemplateClass {
public:T data;MyTemplateClass(T d) : data(d) {}void display() {cout << "Data: " << data << endl;}
};int main() {MyTemplateClass<int> intObj(42);intObj.display(); // 输出: Data: 42MyTemplateClass<double> doubleObj(3.14);doubleObj.display(); // 输出: Data: 3.14return 0;
}

8. 异常处理

用于处理运行时错误。

#include <iostream>
#include <exception>
using namespace std;class MyException : public exception {
public:const char* what() const throw() {return "My custom exception";}
};void throwException() {throw MyException();
}int main() {try {throwException();} catch (const MyException& e) {cout << "Caught exception: " << e.what() << endl; // 输出: Caught exception: My custom exception}return 0;
}

9. 智能指针

自动管理内存，避免内存泄漏。

#include <iostream>
#include <memory>
using namespace std;class MyClass {
public:void display() {cout << "Display" << endl;}
};int main() {unique_ptr<MyClass> ptr(new MyClass());ptr->display(); // 输出: Displayreturn 0;
}

10. 继承和多态

继承允许子类继承父类的特性，多态允许同一接口有多种实现。

#include <iostream>
using namespace std;class Base {
public:virtual void display() const {cout << "Base class display" << endl;}virtual ~Base() {}
};class Derived : public Base {
public:void display() const override {cout << "Derived class display" << endl;}
};int main() {Base* b = new Derived();b->display(); // 输出: Derived class displaydelete b;return 0;
}

11. 纯虚函数和抽象类

纯虚函数使得类成为抽象类，不能直接实例化。

#include <iostream>
using namespace std;class AbstractBase {
public:virtual void pureVirtualFunction() const = 0;virtual ~AbstractBase() {}
};class ConcreteDerived : public AbstractBase {
public:void pureVirtualFunction() const override {cout << "Concrete implementation" << endl;}
};int main() {AbstractBase* a = new ConcreteDerived();a->pureVirtualFunction(); // 输出: Concrete implementationdelete a;return 0;
}

12. 友元函数和友元类

友元可以访问类的私有成员。

#include <iostream>
using namespace std;class MyClass {
private:int privateData;public:MyClass(int data) : privateData(data) {}friend void friendFunction(const MyClass& obj);friend class FriendClass;
};void friendFunction(const MyClass& obj) {cout << "Private data: " << obj.privateData << endl;
}class FriendClass {
public:void display(const MyClass& obj) {cout << "Private data: " << obj.privateData << endl;}
};int main() {MyClass obj(42);friendFunction(obj); // 输出: Private data: 42FriendClass fc;fc.display(obj); // 输出: Private data: 42return 0;
}

13. 嵌套类

嵌套类是定义在另一个类内部的类。

#include <iostream>
using namespace std;class OuterClass {
public:class InnerClass {public:void display() const {cout << "Inner class display" << endl;}};void outerFunction() {InnerClass inner;inner.display();}
};int main() {OuterClass::InnerClass inner;inner.display(); // 输出: Inner class displayOuterClass outer;outer.outerFunction(); // 输出: Inner class displayreturn 0;
}

14. 静态成员

静态成员属于类，而不是某个具体的对象。

#include <iostream>
using namespace std;class MyClass {
public:static int staticData;static void staticFunction() {cout << "Static data: " << staticData << endl;}
};int MyClass::staticData = 10;int main() {MyClass::staticFunction(); // 输出: Static data: 10MyClass::staticData = 20;MyClass::staticFunction(); // 输出: Static data: 20return 0;
}

15. 类型转换运算符

类型转换运算符允许将类的对象转换为其他类型。

#include <iostream>
using namespace std;class MyInteger {
private:int value;public:MyInteger(int val) : value(val) {}operator int() const {return value;}
};int main() {MyInteger mi(42);int num = mi; // 使用类型转换运算符cout << "num: " << num << endl; // 输出: num: 42return 0;
}

16. 命名空间

命名空间用于避免名称冲突。

#include <iostream>
using namespace std;namespace MyNamespace {void display() {cout << "Namespace display" << endl;}
}int main() {MyNamespace::display(); // 输出: Namespace displayreturn 0;
}