从C到C++ | C++入门(三)

**从C到C++ | C++入门(三)**在前两篇文章中，我们已经介绍了C语言的基本语法和一些常用函数库。今天我们将继续讨论C++语言的特点和基本语法。

###1. 类型系统C++保留了C语言中的类型系统，但也引入了一些新的类型，如`const`、`volatile`等。

####1.1 `const`

`const`关键字用于声明一个常量变量。例如：

cppconst int MAX_SIZE =100;

在这个例子中，`MAX_SIZE`是一个常量变量，其值为100。

####1.2 `volatile`

`volatile`关键字用于声明一个易变的变量。例如：

cppvolatile int count =0;

在这个例子中，`count`是一个易变的变量，其值可能会改变。

###2. 函数C++保留了C语言中的函数定义方式，但也引入了一些新的函数特性，如重载、运算符重载等。

####2.1 重载重载是指在同一个作用域中，多个函数具有相同的名称，但参数列表不同。例如：

cppvoid print(int num) {
 std::cout << "整数：" << num << std::endl;
}

void print(double num) {
 std::cout << "浮点数：" << num << std::endl;
}

在这个例子中，`print()`函数被重载了两次，分别用于打印整数和浮点数。

####2.2 运算符重载运算符重载是指在类中重新定义一些运算符的行为。例如：

cppclass Point {
public:
 int x, y;

 Point(int x =0, int y =0) : x(x), y(y) {}

 friend std::ostream& operator<<(std::ostream& os, const Point& p) {
 return os << "(" << p.x << ", " << p.y << ")";
 }
};

int main() {
 Point p(3,4);
 std::cout << p << std::endl;
 return0;
}

在这个例子中，`<<`运算符被重载了，以便打印一个`Point`对象。

###3. 类C++引入了一种新的数据类型——类。类是用来描述一个事物的属性和行为的。

####3.1 类定义类定义遵循以下格式：

cppclass ClassName {
public:
 // 成员函数private:
 // 成员变量};

例如：

cppclass Person {
public:
 void sayHello() {
 std::cout << "Hello, my name is " << name << "." << std::endl;
 }

private:
 std::string name;
};

在这个例子中，`Person`类定义了一个名为`sayHello()`的成员函数和一个名为`name`的成员变量。

####3.2 构造函数构造函数是用来初始化对象的特殊成员函数。例如：

cppclass Person {
public:
 Person(std::string name) : name(name) {}

private:
 std::string name;
};

在这个例子中，`Person`类定义了一个名为`name`的构造函数。

####3.3 析构函数析构函数是用来释放资源的特殊成员函数。例如：

cppclass Person {
public:
 ~Person() {
 std::cout << "Goodbye, " << name << "." << std::endl;
 }

private:
 std::string name;
};

在这个例子中，`Person`类定义了一个名为`~Person()`的析构函数。

###4. 继承C++支持多种继承方式，如公有继承、私有继承等。

####4.1 公有继承公有继承是指子类继承父类所有成员。例如：

cppclass Animal {
public:
 void eat() {
 std::cout << "Eating..." << std::endl;
 }
};

class Dog : public Animal {
public:
 void bark() {
 std::cout << "Barking..." << std::endl;
 }
};

在这个例子中，`Dog`类继承了`Animal`类的所有成员。

####4.2 私有继承私有继承是指子类继承父类的私有成员，但不能直接访问。例如：

cppclass Animal {
private:
 void eat() {
 std::cout << "Eating..." << std::endl;
 }
};

class Dog : private Animal {
public:
 void bark() {
 //eat(); // Error: 'void Animal::eat()' is inaccessible }
};

在这个例子中，`Dog`类继承了`Animal`类的私有成员，但不能直接访问。

###5. 多态多态是指一个函数或运算符可以根据不同的对象类型表现出不同的行为。例如：

cppclass Shape {
public:
 virtual void draw() =0;
};

class Circle : public Shape {
public:
 void draw() override {
 std::cout << "Drawing a circle..." << std::endl;
 }
};

class Rectangle : public Shape {
public:
 void draw() override {
 std::cout << "Drawing a rectangle..." << std::endl;
 }
};

在这个例子中，`draw()`函数根据不同的对象类型表现出不同的行为。

###6. 模板模板是指一种可以根据不同数据类型自动生成代码的机制。例如：

cpptemplate <typename T>
class Container {
public:
 void add(T value) {
 values.push_back(value);
 }

private:
 std::vector<T> values;
};

在这个例子中，`Container`类模板根据不同数据类型自动生成代码。

###7. 智能指针智能指针是指一种可以自动释放资源的指针。例如：

cppclass SmartPointer {
public:
 template <typename T>
 explicit SmartPointer(T* ptr) : ptr_(ptr) {}

 ~SmartPointer() { delete ptr_; }

 T& operator*() const { return *ptr_; }
 T* operator->() const { return ptr_; }

private:
 T* ptr_;
};

在这个例子中，`SmartPointer`类模板可以自动释放资源。

###8. lambda表达式lambda表达式是指一种可以直接定义函数的语法。例如：

cppauto add = [](int a, int b) { return a + b; };

在这个例子中，`add`变量被赋值为一个lambda表达式。

###9. 绑定绑定是指一种可以将函数参数绑定到特定值的机制。例如：

cppauto add = std::bind([](int a, int b) { return a + b; },5);

在这个例子中，`add`变量被赋值为一个绑定对象。

###10. move语义move语义是指一种可以将对象移动到另一个位置的机制。例如：

cppclass Moveable {
public:
 Moveable() { std::cout << "Moveable constructed." << std::endl; }
 Moveable(Moveable&& other) : value_(other.value_) {
 other.value_ =0;
 std::cout << "Moveable moved." << std::endl;
 }

private:
 int value_;
};

在这个例子中，`Moveable`类支持move语义。

###11. 右值引用右值引用是指一种可以绑定到临时对象的引用。例如：

cppauto add = [](int a, int b) { return a + b; };
auto result = std::move(add(5,3));

在这个例子中，`result`变量被赋值为一个右值引用。

###12. std::forwardstd::forward是指一种可以将参数传递给函数的机制。例如：

cpptemplate <typename T>
void forward(T&& value) {
 std::cout << "Forwarding..." << std::endl;
}

int main() {
 int x =5;
 forward(x); // Forwarding...
 return0;
}

在这个例子中，`forward()`函数使用std::forward将参数传递给另一个函数。

###13. std::movestd::move是指一种可以移动对象的机制。例如：

cppclass Moveable {
public:
 Moveable() { std::cout << "Moveable constructed." << std::endl; }
};

int main() {
 Moveable x;
 Moveable y = std::move(x);
 return0;
}