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: 42
    return 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 + 6i
    return 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: 42
    cout << "obj3.data: " << obj3.data << endl; // 输出: obj3.data: 42
    return 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: 42

    MyTemplateClass<double> doubleObj(3.14);
    doubleObj.display(); // 输出: Data: 3.14
    return 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(); // 输出: Display
    return 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 display
    delete 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 implementation
    delete 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: 42

    FriendClass fc;
    fc.display(obj); // 输出: Private data: 42
    return 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 display

    OuterClass outer;
    outer.outerFunction(); // 输出: Inner class display
    return 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: 10
    MyClass::staticData = 20;
    MyClass::staticFunction(); // 输出: Static data: 20
    return 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: 42
    return 0;
}

16. 命名空间

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

#include <iostream>
using namespace std;

namespace MyNamespace {
    void display() {
        cout << "Namespace display" << endl;
    }
}

int main() {
    MyNamespace::display(); // 输出: Namespace display
    return 0;
}

总结

通过这次整合，我们全面探讨了C++类的各个方面，从基本概念到高级特性，如继承、多态、纯虚函数、友元、嵌套类、静态成员、类型转换和命名空间等。这些特性使得C++在面向对象编程中非常强大和灵活。