C++11教程：从入门到实践

本文提供了全面的C++11教程，涵盖了从语言历史到新特性介绍，环境搭建，基础语法，控制结构，面向对象编程以及C++11新特性应用等多个方面。通过本文的学习，读者可以掌握C++11的基本使用方法，提高编程效率和代码的可读性。

C++11简介

C++11的历史背景

C++ 是一种通用的编程语言，由 Bjarne Stroustrup 于 1983 年在贝尔实验室开发。C++ 语言在发展过程中经历了多次更新和改进，以适应不断变化的软件开发需求。C++11 是 C++ 标准的一个重要版本，于 2011 年正式发布，引入了许多新特性，提高了编程效率和代码的可读性。

C++11的主要新特性

C++11 引入了许多新特性，如类型推导、智能指针、范围基于 for 循环、lambda 表达式等，这些新特性极大地提高了代码的简洁性与现代性。以下是 C++11 的一些重要新特性：

• 类型推导：auto 关键字允许编译器根据初始化表达式推导变量类型。
• 智能指针：std::unique_ptr 和 std::shared_ptr 提供了更安全的内存管理方式。
• 范围基于 for 循环：简化了数组和容器的迭代。
• lambda 表达式：提供了一种内联匿名函数的方式。
• 右侧值引用：std::move 和 std::forward 用于移动语义和完美转发。

C++11环境搭建

要开始使用 C++11，首先需要安装一个支持 C++11 的编译器。目前常用的编译器有 GCC 和 Clang。以下是安装和配置环境的步骤：

1. 安装 GCC：

   • 在 Linux 上，可以通过包管理器安装：

     sudo apt-get update
     sudo apt-get install g++

   • 在 Windows 上，可以下载并安装 MinGW-w64。
   • 在 macOS 上，可以使用 Homebrew 安装：

     brew install gcc

2. 设置编译器：
   • 使用 g++ 或 clang++ 编译器编译代码，同时指定 C++11 标准：

     g++ -std=c++11 main.cpp -o main

基础语法与变量类型

变量声明与初始化

在 C++ 中，变量声明和初始化是基础操作。变量声明指定了变量的类型和名称，而初始化则是给变量赋予初始值。以下是变量声明和初始化的示例：

int age = 25; // 整型变量
float pi = 3.14; // 浮点型变量
char grade = 'A'; // 字符型变量
bool isStudent = true; // 布尔型变量

数据类型

C++ 中有多种基本数据类型，包括整型、浮点型、字符型和布尔型等。每种类型有不同的用途和范围。

• 整型：int、short、long、unsigned int 等。

  short age = 25; // 整型变量
  long longNumber = 1000000000; // 长整型变量
  unsigned int count = 100; // 无符号整型变量

• 浮点型：float 和 double。

  float pi = 3.14; // 浮点型变量
  double precisionPi = 3.141592653589793; // 双精度浮点型变量

• 字符型：char。

  char grade = 'A'; // 字符型变量

• 布尔型：bool。

  bool isStudent = true; // 布尔型变量

常量和引用

常量和引用是 C++ 中的两种高级数据类型。

• 常量：使用 const 关键字声明常量，其值在声明后不可更改。

  const int MAX_SIZE = 100;

• 引用：通过 & 符号声明引用，引用是变量的别名，但不是变量本身。

  int num = 42;
  int& ref = num;
  ref = 100; // num 也变为 100

控制结构与函数

条件语句（if-else）

条件语句用于根据条件判断执行不同的代码块。if-else 语句是最常见的条件结构之一。

int value = 20;
if (value > 15) {
    std::cout << "Value is greater than 15";
} else {
    std::cout << "Value is less than or equal to 15";
}

循环语句（for, while）

循环语句允许代码块重复执行，直到满足某个条件。

• for 循环：

  int sum = 0;
  for (int i = 1; i <= 10; i++) {
    sum += i;
  }
  std::cout << "Sum: " << sum << std::endl;

• while 循环：

  int count = 0;
  while (count < 5) {
    std::cout << "Count: " << count << std::endl;
    count++;
  }

函数定义与调用

函数是执行特定任务的代码块。通过函数可以实现代码的模块化和重用。

• 定义函数：

  int add(int a, int b) {
    return a + b;
  }

• 调用函数：

  int result = add(3, 5);
  std::cout << "Result: " << result << std::endl;

参数传递与返回值

参数传递是将值传递给函数。返回值是函数执行后返回的结果。

• 传值参数：传递一个变量的副本。

  int square(int x) {
    return x * x;
  }

• 引用参数：传递变量的引用，允许修改原始值。

  void swap(int& a, int& b) {
    int temp = a;
    a = b;
    b = temp;
  }

数组与指针

数组的定义与使用

数组是一种可以存储一组相同类型数据的数据结构。数组中的每个元素可以通过索引访问。

int numbers[5] = {1, 2, 3, 4, 5};
for (int i = 0; i < 5; i++) {
    std::cout << numbers[i] << std::endl;
}

指针的基本概念

指针是一种变量，用于存储另一个变量的内存地址。通过指针可以间接访问和修改内存中的数据。

• 声明指针：

  int* ptr;

• 分配内存：

  int number = 100;
  int* ptr = &number;

动态内存分配

动态内存分配允许在程序运行时分配内存。使用 new 和 delete 关键字进行动态内存管理。

int* dynamicArray = new int[5];
for (int i = 0; i < 5; i++) {
    dynamicArray[i] = i * 10;
}
for (int i = 0; i < 5; i++) {
    std::cout << dynamicArray[i] << std::endl;
}
delete[] dynamicArray;

数组与指针的关系

数组和指针之间有密切的关联。数组本质上是一个指针，指向数组的第一个元素。

int arr[5] = {1, 2, 3, 4, 5};
int* ptr = arr; // ptr 指向数组的第一个元素

面向对象编程

类和对象的定义

类是对象的模板，定义了对象的数据成员和方法。对象是类的实例。

class Person {
public:
    std::string name;
    int age;

    void display() {
        std::cout << "Name: " << name << ", Age: " << age << std::endl;
    }
};

Person person;
person.name = "Alice";
person.age = 25;
person.display();

成员函数与成员变量

成员函数是定义在类中的函数，可以操作类的成员变量。

class Rectangle {
public:
    int width;
    int height;

    int area() {
        return width * height;
    }
};

Rectangle rect;
rect.width = 10;
rect.height = 5;
std::cout << "Area: " << rect.area() << std::endl;

构造函数与析构函数

构造函数是创建对象时自动调用的特殊成员函数，析构函数是在对象销毁时调用的特殊成员函数。

class Point {
public:
    int x;
    int y;

    Point(int x, int y) : x(x), y(y) {} // 构造函数

    ~Point() {
        std::cout << "Point destroyed" << std::endl; // 析构函数
    }
};

Point p(10, 20);

封装、继承与多态

• 封装：将数据和操作数据的方法封装在一起，通过公有接口提供访问。
• 继承：允许一个类继承另一个类的属性和方法，实现代码重用。
• 多态：允许不同对象对同一消息作出不同响应。

class Shape {
public:
    virtual void draw() = 0; // 定义纯虚函数
};

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

class Square : public Shape {
public:
    void draw() {
        std::cout << "Drawing Square" << std::endl;
    }
};

int main() {
    Shape* shape1 = new Circle();
    Shape* shape2 = new Square();
    shape1->draw(); // 输出 "Drawing Circle"
    shape2->draw(); // 输出 "Drawing Square"
    return 0;
}

C++11新特性应用

auto关键字

auto 关键字允许编译器自动推导变量类型，简化代码编写。

auto value = 42; // 编译器推断 value 为 int
auto pi = 3.14; // 编译器推断 pi 为 double
auto text = "Hello"; // 编译器推断 text 为 const char*

range-based for循环

range-based for 循环简化了容器和数组的遍历。

std::vector<int> numbers = {1, 2, 3, 4, 5};
for (auto& num : numbers) {
    num *= 2;
}
for (const auto& num : numbers) {
    std::cout << num << std::endl;
}

lambda表达式

lambda 表达式提供了一种内联匿名函数的方式，适合用在回调函数等场景中。

auto func = [](int x, int y) {
    return x + y;
};
std::cout << "Result: " << func(3, 5) << std::endl;

异常处理

异常处理机制允许在程序运行时捕获和处理错误，提高代码的健壮性。

void readFile(const std::string& filename) {
    try {
        std::ifstream file(filename);
        if (!file.is_open()) {
            throw std::runtime_error("File not found");
        }
        // 读取文件内容
    } catch (const std::runtime_error& e) {
        std::cerr << "Error: " << e.what() << std::endl;
    }
}
readFile("example.txt");
``

以上是 C++11 教程从入门到实践的详细内容，涵盖了从基础语法到高级特性的各个方面。通过本文的学习，读者可以掌握 C++11 的基本使用方法，为后续深入学习打下坚实的基础。