C++ 对C的扩展有哪些

C++对C的扩展主要体现在以下几个方面：

1. 语法增强：
   • 变量声明位置更灵活：在C语言中，函数内的所有局部变量必须在函数开头的块内进行声明。而C++放松了这一限制，可以在函数内的任何位置声明变量，只要在使用该变量之前进行声明即可。例如：

   void someFunction() {
       // C++中可以在循环内部声明变量
       for (int i = 0; i < 10; i++) {
           // 这里的 i 是在循环内部声明的局部变量
           std::cout << i << std::endl;
       }
   }
   

   • 支持默认参数：C++允许为函数的参数指定默认值。在调用函数时，如果没有提供相应的参数值，则使用默认值。这使得函数调用更加灵活和方便。例如：

   void printMessage(std::string message = "Hello, World!") {
       std::cout << message << std::endl;
   }
   
   int main() {
       // 调用函数时使用默认参数
       printMessage();
       // 也可以传入自己的参数
       printMessage("This is a custom message.");
       return 0;
   }
   

2. 数据类型扩展与增强：
   • 新增bool类型：C语言中没有专门的布尔类型，通常用整数来表示逻辑值（0 表示假，非 0 表示真）。C++引入了bool类型，取值为true（表示真）和false（表示假），使逻辑表达更加清晰和直观。例如：

   bool isTrue = true;
   bool isFalse = false;
   

   • 对const的增强：在C语言中，const关键字的作用主要是限制变量的值不能被修改，但在复杂的表达式中，其语义可能不太明确。C++中的const更加强大，可以用于修饰函数的参数、返回值以及成员函数等，提供更好的常量性保证和代码的安全性。例如：

   void someFunction(const int parameter) {
       // 在函数内部无法修改 parameter 的值
   }
   

3. 面向对象特性：
   • 类和对象：这是C++最重要的扩展之一。C++支持面向对象编程，允许定义类来封装数据和操作。类可以包含成员变量（数据）和成员函数（操作），通过类可以创建对象，实现数据的隐藏和封装、继承、多态等面向对象的特性。例如：

   class Rectangle {
   private:
       int width;
       int height;
   public:
       Rectangle(int w, int h) : width(w), height(h) {}
       int getArea() const {
           return width * height;
       }
   };
   
   int main() {
       Rectangle rect(5, 10);
       std::cout << "Area: " << rect.getArea() << std::endl;
       return 0;
   }
   

   • 运算符重载：C++允许用户自定义运算符的行为，以便对自定义类型的对象进行操作。通过运算符重载，可以使代码更加简洁和直观。例如，可以为自定义的类重载+、-、*、/等运算符。

   class Complex {
   private:
       double real;
       double imag;
   public:
       Complex(double r = 0.0, double i = 0.0) : real(r), imag(i) {}
       // 重载 + 运算符
       Complex operator+(const Complex& other) const {
           return Complex(real + other.real, imag + other.imag);
       }
   };
   

4. 输入输出流：
   • C++提供了更强大、更灵活的输入输出流（iostream库）来替代C语言中的printf和scanf函数。输入输出流使用<<和>>运算符进行操作，支持各种数据类型的输入和输出，并且具有更好的类型安全性和可扩展性。例如：

   #include <iostream>
   
   int main() {
       int num;
       std::cout << "Enter a number: ";
       std::cin >> num;
       std::cout << "You entered: " << num << std::endl;
       return 0;
   }
   

5. 命名空间：在大型项目中，可能会出现命名冲突的问题。C++引入了命名空间的概念，可以将代码封装在不同的命名空间中，避免命名冲突。命名空间还可以嵌套使用，并且可以随时向已有的命名空间中添加新的成员。例如：

   namespace namespace1 {
       int variable = 10;
       void function() {
           std::cout << "This is function in namespace1" << std::endl;
       }
   }
   
   namespace namespace2 {
       int variable = 20;
       void function() {
           std::cout << "This is function in namespace2" << std::endl;
       }
   }
   

6. 异常处理：C++提供了异常处理机制，用于处理程序运行时可能出现的错误和异常情况。通过try-catch语句块，可以捕获和处理异常，使程序更加健壮和可靠。例如：

   int divide(int a, int b) {
       if (b == 0) {
           throw "Division by zero error!";
       }
       return a / b;
   }
   
   int main() {
       try {
           int result = divide(10, 0);
           std::cout << "Result: " << result << std::endl;
       } catch (const char* errorMessage) {
           std::cerr << "Error: " << errorMessage << std::endl;
       }
       return 0;
   }
   

7. 模板：模板是C++的一种高级特性，包括函数模板和类模板。函数模板可以根据不同的参数类型自动生成相应的函数版本，类模板可以根据不同的类型参数创建不同的类实例。模板提高了代码的复用性和可扩展性。例如：

   // 函数模板
   template <typename T>
   T maximum(T a, T b) {
       return (a > b)? a : b;
   }
   
   // 类模板
   template <typename T>
   class Stack {
   private:
       T* data;
       int size;
   public:
       Stack() : size(0) {
           data = new T[10];
       }
       ~Stack() {
           delete[] data;
       }
       void push(T value) {
           data[size++] = value;
       }
       T pop() {
           return data[--size];
       }
   };
   

8. 增强的结构体：在C++中，结构体不仅可以包含成员变量，还可以包含成员函数，这使得结构体的功能更加强大，可以像类一样进行封装和操作。例如：

   struct Point {
       int x;
       int y;
       // 结构体内部的成员函数
       void print() const {
           std::cout << "(" << x << ", " << y << ")" << std::endl;
       }
   };