本文详细介绍了C++11的主要特性和环境搭建步骤，帮助读者快速掌握C++11入门知识。文章涵盖了C++11的新特性、开发环境配置及基础语法，旨在让读者能够轻松上手C++11编程。

C++11是C++标准之一，于2011年正式发布。它引入了许多新特性和改进，使得C++更加现代化和方便使用。C++11的主要目标是提高语言的安全性、简化语法、提供更好的并行编程支持以及增强对现代硬件的支持。

C++11带来了大量的新特性，具体如下：

1. 类型推断：通过auto关键字自动推断变量类型。
2. 范围for循环：简化数组和容器的遍历。
3. 智能指针：std::unique_ptr、std::shared_ptr和std::weak_ptr提供了更安全的内存管理。
4. 初始化列表：使用{}对变量进行初始化。
5. 右值引用：改进了移动语义和完美转发。
6. Lambda表达式：简化了匿名函数的定义。
7. 模板推导：更好的模板参数推导。
8. 新的库功能：如<chrono>、<thread>、<regex>等。
9. 更好的类型安全：新的类型如nullptr和static_assert。
10. 更多元的数据类型：像long long和constexpr等。

这些特性大大提高了C++代码的可读性和安全性，同时也简化了许多常见的编程任务。

搭建C++11开发环境的基本步骤如下：

1. 安装编译器：确保你的编译器支持C++11。GCC和Clang都支持C++11，可以通过命令行编译器或集成开发环境（IDE）来使用。
2. 设置环境变量：确保编译器路径已经添加到环境变量中。
3. 使用IDE：可以选择Visual Studio、Code::Blocks、Eclipse CDT等。
4. 编写代码：创建一个简单的C++11程序。
5. 编译与运行：使用命令行或IDE编译并运行你的程序。

• 编译器：GCC、Clang
• IDE：Visual Studio、Code::Blocks、Eclipse CDT、VIM、Sublime Text

接下来，我们来设置一个简单的开发环境，并编写一个C++11程序来测试这些工具。

示例代码

#include <iostream>

int main() {
    std::cout << "Hello, World!" << std::endl;
    return 0;
}

编译并运行这个程序，确保你的环境配置正确。

在C++中，变量是用来存储数据的容器。在声明变量时，需要指定其类型。

示例代码

int main() {
    int age = 25;
    char grade = 'A';
    double salary = 3500.50;
    bool isStudent = true;

    return 0;
}

其他类型

• 整型：int、short、long、long long
• 浮点型：float、double、long double
• 字符型：char、wchar_t
• 布尔型：bool
• 无类型：void
• 枚举型：enum

常量是不可改变的数据。通常使用const关键字来声明常量。

示例代码

int main() {
    const int maxAge = 100;
    const double pi = 3.14159;

    return 0;
}

字面量

C++中的字面量可以是数字或字符串。它们用于直接赋予变量初始值。

int main() {
    int num = 42;
    double price = 9.99;
    char letter = 'A';
    const char* str = "Hello, World!";

    return 0;
}

C++支持多种运算符，如算术运算符、关系运算符、逻辑运算符等。表达式是由运算符和操作数组成的。

示例代码

int main() {
    int a = 10;
    int b = 5;

    int sum = a + b;
    int difference = a - b;
    int product = a * b;
    int quotient = a / b;
    int remainder = a % b;

    bool isEqual = (a == b);
    bool isNotEqual = (a != b);

    return 0;
}

使用<iostream>库来处理输入输出操作。

示例代码

#include <iostream>

int main() {
    int number;
    std::cout << "请输入一个数字: ";
    std::cin >> number;
    std::cout << "你输入的数字是: " << number << std::endl;

    return 0;
}

文件操作

使用<fstream>库来处理文件输入输出操作。

示例代码

#include <iostream>
#include <fstream>

int main() {
    std::ofstream file("output.txt");
    file << "Hello, World!";
    file.close();

    std::ifstream inputFile("output.txt");
    std::string content;
    inputFile >> content;
    std::cout << "文件内容: " << content << std::endl;

    return 0;
}

条件语句用于根据条件执行不同的代码块。

示例代码

#include <iostream>

int main() {
    int age = 20;

    if (age >= 18) {
        std::cout << "成年人" << std::endl;
    } else {
        std::cout << "未成年人" << std::endl;
    }

    return 0;
}

循环语句用于重复执行一段代码。

示例代码

#include <iostream>

int main() {
    for (int i = 0; i < 5; i++) {
        std::cout << "循环次数 " << i << std::endl;
    }

    int j = 0;
    while (j < 5) {
        std::cout << "循环次数 " << j << std::endl;
        j++;
    }

    int k = 0;
    do {
        std::cout << "循环次数 " << k << std::endl;
        k++;
    } while (k < 5);

    return 0;
}

跳转语句用于改变程序执行的流程，包括break、continue和goto。

示例代码

#include <iostream>

int main() {
    for (int i = 0; i < 10; i++) {
        if (i == 5) {
            break;
        }
        std::cout << "i = " << i << std::endl;
    }

    for (int i = 0; i < 10; i++) {
        if (i % 2 == 0) {
            continue;
        }
        std::cout << "i = " << i << std::endl;
    }

    int x = 0;
    label:
    std::cout << "x = " << x << std::endl;
    if (x == 2) {
        goto label;
    }
    x++;

    return 0;
}

更复杂的goto使用案例

#include <iostream>

int main() {
    int x = 0;
    process:
    x++;
    if (x < 5) {
        goto process;
    }
    std::cout << "x = " << x << std::endl;
    return 0;
}

代码块是一个由大括号{}包围的代码块，作用域在代码块内有效。

示例代码

#include <iostream>

int main() {
    {
        int x = 5;
        std::cout << "x 在代码块内: " << x << std::endl;
    }
    // x 在这里无法访问

    return 0;
}

函数是可重用的代码块，用于执行特定任务。

示例代码

#include <iostream>

void displayMessage() {
    std::cout << "Hello, World!" << std::endl;
}

int main() {
    displayMessage();
    return 0;
}

可以将参数传递给函数。

示例代码

#include <iostream>

void displayNumber(int num) {
    std::cout << "数字是: " << num << std::endl;
}

int main() {
    displayNumber(42);
    return 0;
}

函数可以返回值，使用return关键字。

示例代码

#include <iostream>

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

int main() {
    int result = addNumbers(10, 20);
    std::cout << "结果是: " << result << std::endl;
    return 0;
}

递归函数是调用自身的函数。

示例代码

#include <iostream>

int factorial(int n) {
    if (n == 0) {
        return 1;
    } else {
        return n * factorial(n - 1);
    }
}

int main() {
    int result = factorial(5);
    std::cout << "5 的阶乘是: " << result << std::endl;
    return 0;
}

更复杂的递归函数

#include <iostream>

int fibonacci(int n) {
    if (n < 2) {
        return n;
    } else {
        return fibonacci(n - 1) + fibonacci(n - 2);
    }
}

int main() {
    int result = fibonacci(10);
    std::cout << "10 的斐波那契数是: " << result << std::endl;
    return 0;
}

类是创建对象的蓝图，对象是类的实例。

示例代码

#include <iostream>

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

    void displayInfo() {
        std::cout << "姓名: " << name << std::endl;
        std::cout << "年龄: " << age << std::endl;
    }
};

int main() {
    Person person;
    person.name = "张三";
    person.age = 25;
    person.displayInfo();

    return 0;
}

类中的变量称为成员变量，函数称为成员函数。

示例代码

#include <iostream>

class Rectangle {
public:
    int length;
    int width;

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

int main() {
    Rectangle rect;
    rect.length = 5;
    rect.width = 10;
    std::cout << "面积: " << rect.area() << std::endl;

    return 0;
}

构造函数用于初始化对象，析构函数用于释放资源。

示例代码

#include <iostream>

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

    Person(std::string n, int a) : name(n), age(a) {}

    ~Person() {
        std::cout << "析构函数被调用" << std::endl;
    }

    void displayInfo() {
        std::cout << "姓名: " << name << std::endl;
        std::cout << "年龄: " << age << std::endl;
    }
};

int main() {
    Person person("李四", 30);
    person.displayInfo();

    return 0;
}

继承允许一个类继承另一个类的属性和行为。多态允许通过基类指针或引用调用派生类的方法。

示例代码

#include <iostream>

class Animal {
public:
    virtual void speak() {
        std::cout << "动物说话" << std::endl;
    }
};

class Dog : public Animal {
public:
    void speak() {
        std::cout << "狗叫汪汪" << std::endl;
    }
};

class Cat : public Animal {
public:
    void speak() {
        std::cout << "猫叫喵喵" << std::endl;
    }
};

int main() {
    Animal* animal1 = new Dog();
    animal1->speak();

    Animal* animal2 = new Cat();
    animal2->speak();

    delete animal1;
    delete animal2;

    return 0;
}

更复杂的继承结构

#include <iostream>

class Animal {
public:
    virtual void speak() = 0;
};

class Mammal : public Animal {
public:
    virtual void breathe() {
        std::cout << "哺乳动物呼吸" << std::endl;
    }
};

class Dog : public Mammal {
public:
    void speak() {
        std::cout << "狗叫汪汪" << std::endl;
    }
};

class Cat : public Mammal {
public:
    void speak() {
        std::cout << "猫叫喵喵" << std::endl;
    }
};

int main() {
    Dog dog;
    Cat cat;

    dog.speak();
    cat.speak();

    dog.breathe();
    cat.breathe();

    return 0;
}

智能指针提供了自动内存管理功能，避免了手动管理内存的复杂性。

示例代码

#include <iostream>
#include <memory>

int main() {
    std::unique_ptr<int> uniquePtr(new int(10));
    std::shared_ptr<int> sharedPtr(new int(20));

    *uniquePtr = 50;
    *sharedPtr = 60;

    std::cout << "uniquePtr: " << *uniquePtr << std::endl;
    std::cout << "sharedPtr: " << *sharedPtr << std::endl;

    return 0;
}

使用auto关键字可以自动推断变量类型。

示例代码

#include <iostream>

int main() {
    auto number = 42;
    auto pi = 3.14159;
    auto isTrue = true;

    std::cout << "number: " << number << std::endl;
    std::cout << "pi: " << pi << std::endl;
    std::cout << "isTrue: " << isTrue << std::endl;

    return 0;
}

更复杂的auto使用案例

#include <iostream>

int main() {
    auto arr = new int[5]{1, 2, 3, 4, 5};
    auto size = sizeof(arr) / sizeof(arr[0]);

    for (auto i = 0; i < size; ++i) {
        std::cout << "arr[" << i << "] = " << arr[i] << std::endl;
    }

    delete[] arr;

    return 0;
}

Lambda表达式提供了一种简洁的方法来定义匿名函数。

示例代码

#include <iostream>
#include <vector>
#include <algorithm>

int main() {
    std::vector<int> numbers = {1, 2, 3, 4, 5};

    std::for_each(numbers.begin(), numbers.end(), [](int n) {
        std::cout << n * 2 << std::endl;
    });

    return 0;
}

带有捕获列表和参数的Lambda表达式

#include <iostream>
#include <vector>

int main() {
    std::vector<int> numbers = {1, 2, 3, 4, 5};
    int multiplier = 2;

    for (int& n : numbers) {
        n = n * multiplier;
    }

    for (int n : numbers) {
        std::cout << n << std::endl;
    }

    return 0;
}

C++提供了异常处理机制来处理程序中可能出现的错误。

示例代码

#include <iostream>
#include <stdexcept>

void throwException() {
    throw std::runtime_error("发生了运行时错误");
}

int main() {
    try {
        throwException();
    } catch (const std::exception& e) {
        std::cout << "捕获到的异常: " << e.what() << std::endl;
    }

    return 0;
}

更复杂的异常处理示例

#include <iostream>
#include <stdexcept>

class MyException : public std::exception {
public:
    const char* what() const throw() {
        return "自定义异常";
    }
};

void throwCustomException() {
    throw MyException();
}

int main() {
    try {
        throwCustomException();
    } catch (const MyException& e) {
        std::cout << "捕获到的自定义异常: " << e.what() << std::endl;
    }

    try {
        throwCustomException();
    } catch (const MyException& e) {
        std::cout << "捕获到的自定义异常: " << e.what() << std::endl;
    } catch (const std::exception& e) {
        std::cout << "捕获到的异常: " << e.what() << std::endl;
    }

    return 0;
}

通过以上内容，你已经掌握了C++11的基本语法和一些现代特性的使用方法。更多深入的C++知识，可以访问慕课网(https://www.imooc.com/)进行学习。