AI算法C++学习笔记--C++基础

语法和语言特性：熟悉C++的基本语法，包括变量、数据类型、控制结构、函数、类和对象等。

面向对象编程：理解并能够使用面向对象的编程概念，如封装、继承和多态。

模板和泛型编程：掌握模板的使用，了解泛型编程的概念，这对于编写可重用的代码非常重要。

---

类和对象

在C++中，类（Class）是一种用户自定义的数据类型，它封装了数据（属性）和操作这些数据的方法（行为）。对象（Object）是类的实例，即通过类定义的数据类型的具体变量。

类的定义

类的定义通常包括以下几个部分：

• 访问修饰符：public、private和protected，用于控制类成员的访问权限。

• 数据成员：类的属性，可以是各种数据类型，包括基本类型和其他类类型。

• 成员函数：类的行为，定义了可以对数据成员进行的操作。

下面是一个简单的类定义示例：

class MyClass {
public:
    // 成员函数
    void myFunction() {
        // 函数体
    }

    // 数据成员
    int myVariable;
};

对象的创建

要使用类，需要创建类的对象。对象可以通过类名后跟一对括号来创建，这通常称为对象的实例化。

MyClass myObject; // 创建一个MyClass类型的对象

访问类的成员

可以通过对象访问类的成员（数据成员和成员函数）。访问方式是通过点运算符.或箭头运算符->（如果对象是指针）。

myObject.myFunction(); // 调用成员函数
myObject.myVariable = 10; // 访问数据成员

构造函数和析构函数

• 构造函数：在对象创建时自动调用，用于初始化对象的状态。构造函数与类同名，没有返回类型。

• 析构函数：在对象销毁前自动调用，用于清理工作，如释放内存。析构函数名是在类名前加上波浪号~。

class MyClass {
public:
    // 构造函数
    MyClass() {
        // 初始化代码
    }

    // 析构函数
    ~MyClass() {
        // 清理代码
    }
};

类的继承

C++支持类的继承，允许创建一个新类（派生类），它继承了另一个类（基类）的成员。

class BaseClass {
    // 基类成员
};

class DerivedClass : public BaseClass {
    // 派生类成员
};

多态

多态是面向对象编程的一个重要特性，它允许使用基类指针或引用来操作派生类对象，并根据实际对象的类型来调用相应的函数。

class Base {
public:
    virtual void show() {
        cout << "Base class\n";
    }
};

class Derived : public Base {
public:
    void show() override {
        cout << "Derived class\n";
    }
};

int main() {
    Base* basePtr = new Derived();
    basePtr->show(); // 调用Derived类的show函数
    delete basePtr;
    return 0;
}

类和对象是C++面向对象编程的核心概念。类定义了对象的结构和行为，而对象是类的实例，可以在程序中创建和操作。通过封装、继承和多态等特性，C++的类和对象提供了强大的抽象和模块化能力，使得代码更加清晰、可维护和可扩展。

C++的封装、继承和多态

C++是一种支持面向对象编程（OOP）的语言，它提供了封装、继承和多态这三大特性，这些特性是构建复杂软件系统的基石。

封装（Encapsulation）

封装是将数据（属性）和操作数据的函数（方法）捆绑在一起，形成一个单一的实体，即类。封装提供了对数据的访问控制，通过访问修饰符（public、private、protected）来限制外部对类内部数据的直接访问，从而保护数据不被意外修改。

class MyClass {
private:
    int myVariable; // 私有数据成员

public:
    void setMyVariable(int value) { // 公有成员函数，用于设置私有数据成员的值
        myVariable = value;
    }

    int getMyVariable() { // 公有成员函数，用于获取私有数据成员的值
        return myVariable;
    }
};

在上面的例子中，myVariable是私有成员，外部代码不能直接访问它，但可以通过公有的setMyVariable和getMyVariable函数来访问和修改它的值。

继承（Inheritance）

继承允许一个类（派生类）继承另一个类（基类）的成员（数据和函数）。这使得代码重用成为可能，并且可以建立类之间的层次关系。派生类可以添加新的成员，也可以重写（override）基类的成员函数。

class BaseClass {
public:
    void baseFunction() {
        // 基类函数实现
    }
};

class DerivedClass : public BaseClass {
public:
    void derivedFunction() {
        // 派生类函数实现
    }
};

在上面的例子中，DerivedClass继承了BaseClass，因此它拥有baseFunction和自己的derivedFunction。

多态（Polymorphism）

多态是指同一操作作用于不同的对象，可以有不同的解释，产生不同的执行结果。在C++中，多态通常通过虚函数（virtual functions）来实现。

class Base {
public:
    virtual void show() {
        cout << "Base class\n";
    }
};

class Derived : public Base {
public:
    void show() override {
        cout << "Derived class\n";
    }
};

int main() {
    Base* basePtr = new Derived();
    basePtr->show(); // 调用Derived类的show函数
    delete basePtr;
    return 0;
}

在上面的例子中，Base类有一个虚函数show，Derived类重写了这个函数。通过基类指针basePtr调用show函数时，实际执行的是Derived类的show函数，这就是多态。

总结
封装、继承和多态是C++面向对象编程的三大特性，它们共同作用，使得程序设计更加模块化、可维护和可扩展。封装提供了数据的安全性和代码的组织性，继承促进了代码的重用和层次化设计，多态则允许程序以统一的方式处理不同类型的对象，提高了代码的灵活性和可扩展性。

C++的模板的使用、泛型编程的概念

C++的模板是一种强大的特性，它允许程序员编写与类型无关的代码，这种编程方式被称为泛型编程。模板可以用来创建函数模板和类模板，它们在编译时根据实际使用的类型进行实例化。

函数模板

函数模板允许定义一个通用的函数，它可以处理多种数据类型。下面是一个简单的函数模板示例，用于交换两个变量的值：

template <typename T>
void swap(T &a, T &b) {
    T temp = a;
    a = b;
    b = temp;
}

在这个例子中，typename T是模板参数，T是一个占位符，代表任何数据类型。当调用swap函数时，编译器会根据传入的参数类型自动推导出T的实际类型。

int main() {
    int x = 1, y = 2;
    swap(x, y); // 实例化为 swap<int>

    double a = 1.1, b = 2.2;
    swap(a, b); // 实例化为 swap<double>

    return 0;
}

类模板

类模板允许定义一个通用的类，它可以包含多种数据类型的成员。下面是一个简单的类模板示例，用于存储一个值并提供访问和修改的方法：

template <typename T>
class MyContainer {
private:
    T value;

public:
    MyContainer(T val) : value(val) {}

    void setValue(T val) {
        value = val;
    }

    T getValue() const {
        return value;
    }
};

在这个例子中，MyContainer是一个类模板，T是模板参数。当创建MyContainer的对象时，需要指定T的实际类型。

int main() {
    MyContainer<int> intContainer(10); // 实例化为 MyContainer<int>
    intContainer.setValue(20);
    cout << intContainer.getValue() << endl; // 输出 20

    MyContainer<string> stringContainer("Hello"); // 实例化为 MyContainer<string>
    stringContainer.setValue("World");
    cout << stringContainer.getValue() << endl; // 输出 World

    return 0;
}

泛型编程的概念

泛型编程是一种编程范式，它强调编写独立于特定数据类型的代码。在C++中，模板是实现泛型编程的主要工具。泛型编程的目标是编写高度可重用和类型安全的代码，它允许程序员编写更加抽象和通用的算法和数据结构，而不需要为每种数据类型编写特定的实现。

泛型编程的优点包括：

• 代码重用：通过模板，可以编写一次代码，然后在多种类型上使用。

• 类型安全：模板在编译时进行类型检查，确保类型安全。

• 性能：模板生成的代码通常与手写的特定类型代码一样高效。

然而，泛型编程也有一些缺点，比如编译时间可能会增加，因为每个模板实例都会生成新的代码，以及代码的可读性和可维护性可能会降低，因为模板代码通常比较抽象和复杂。

总结
C++的模板是实现泛型编程的关键特性，它允许程序员编写与类型无关的代码。通过函数模板和类模板，可以创建高度可重用和类型安全的代码，这些代码在编译时根据实际使用的类型进行实例化。泛型编程是现代C++编程中的一个重要组成部分，它有助于提高代码的质量和效率。