C++11入门：简洁教程与实践指南

本文介绍了C++11语言的基础知识和新特性，涵盖了从安装编译器到基本语法和数据类型的学习路径，同时也详细讲解了控制结构、函数、对象与类以及标准模板库(STL)的使用方法，帮助读者快速入门C++11。

C++11基础知识介绍

C++11特性概述

C++11是C++语言的一个重要版本，引入了许多新特性，旨在提高代码的可读性和简洁性。以下是一些主要的新特性：

1. 自动类型推断：auto关键字可以自动推断变量类型。
2. 范围for循环：简化遍历容器的语法。
3. 智能指针：帮助管理内存，防止内存泄漏。
4. lambda表达式：允许在代码中定义匿名函数。
5. 右值引用和移动语义：改进资源管理，提升效率。
6. 类型别名：使用using关键字定义类型别名。
7. 尾置返回类型：简化函数返回类型的定义。
8. 正则表达式：引入了新的正则表达式库。
9. 原子操作：支持原子性操作，简化多线程编程。

安装与开发环境配置

为了开始使用C++11，首先需要安装一个支持C++11标准的编译器。常见的编译器有GCC和Clang。

1. 安装GCC：

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

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

   • 在Windows上，可以使用MinGW或通过安装Visual Studio。
2. 配置开发环境：
   • IDE：推荐使用Visual Studio Code或者Eclipse。
   • 集成开发环境（IDE）配置：
     • Visual Studio Code：
       • 安装C++扩展，通过打开命令面板（Ctrl+Shift+P）搜索并安装C++ for VS Code。
       • 配置C/C++扩展，确保设置正确的编译器路径。
     • Eclipse：
       • 安装Eclipse CDT插件，通过帮助菜单选择安装新软件。
       • 配置项目属性，确保使用正确的编译器。

基本语法与程序结构

C++程序的基本结构如下：

#include <iostream>

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

• #include：包含头文件，引入所需的库或定义。
• int main()：程序的入口，所有C++程序都从main函数开始执行。
• std::cout：标准输出流，用于输出信息到控制台。
• std::endl：输出换行符并刷新流。

变量与数据类型

基本数据类型

C++提供了多种基本数据类型，包括整型、浮点型、字符型和布尔型。

• 整型：

  • int：整数类型。
  • short：短整型。
  • long：长整型。
  • long long：更长整型。

• 浮点型：

  • float：单精度浮点数。
  • double：双精度浮点数。
  • long double：扩展精度浮点数。

• 字符型：

  • char：单个字符。
• 布尔型：
  • bool：布尔值，只能取true或false。

示例代码：

#include <iostream>

int main() {
    int a = 5;
    short b = 3;
    long c = 100000;
    long long d = 1000000000;
    float e = 3.14;
    double f = 2.71828;
    long double g = 1.0e100;
    char h = 'A';
    bool i = true;

    std::cout << "a: " << a << ", b: " << b << ", c: " << c << ", d: " << d
              << ", e: " << e << ", f: " << f << ", g: " << g
              << ", h: " << h << ", i: " << i << std::endl;
    return 0;
}

复合数据类型

C++提供了多种复合数据类型，包括数组、结构体和联合体。

• 数组：
  • 固定大小的元素集合。
  • 示例代码：

#include <iostream>

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

• 结构体：
  • 用户定义的数据类型，可以包含多种类型的数据成员。
  • 示例代码：

#include <iostream>

struct Point {
    int x;
    int y;
};

int main() {
    Point p;
    p.x = 10;
    p.y = 20;
    std::cout << "Point: (" << p.x << ", " << p.y << ")" << std::endl;
    return 0;
}

• 联合体：
  • 允许在相同的内存位置存储不同类型的变量。
  • 示例代码：

#include <iostream>

union UnionExample {
    int i;
    char c;
    float f;
};

int main() {
    UnionExample u;
    u.i = 10;
    std::cout << "u.i: " << u.i << std::endl;
    u.c = 'A';
    std::cout << "u.c: " << u.c << std::endl;
    return 0;
}

C++11新增数据类型

C++11引入了一些新的数据类型，如auto关键字和decltype。

• auto关键字：
  • 自动推断变量类型。
  • 示例代码：

#include <iostream>

int main() {
    auto a = 5;
    auto b = 3.14f;
    auto c = "Hello";
    auto d = true;

    std::cout << "a: " << a << ", b: " << b << ", c: " << c << ", d: " << d << std::endl;
    return 0;
}

• decltype：
  • 获取变量或表达式的类型。
  • 示例代码：

#include <iostream>

int main() {
    int a = 5;
    auto b = decltype(a)();
    std::cout << "a: " << a << ", b: " << b << std::endl;
    return 0;
}

控制结构与函数

条件语句

C++提供了多种条件语句，如if、else if和switch。

• if语句：
  • 基本形式：

#include <iostream>

int main() {
    int a = 5;
    if (a > 10) {
        std::cout << "a is greater than 10" << std::endl;
    } else {
        std::cout << "a is less than or equal to 10" << std::endl;
    }
    return 0;
}

• switch语句：
  • 用于多个条件的选择。

#include <iostream>

int main() {
    int a = 2;
    switch (a) {
        case 1:
            std::cout << "a is 1" << std::endl;
            break;
        case 2:
            std::cout << "a is 2" << std::endl;
            break;
        default:
            std::cout << "a is neither 1 nor 2" << std::endl;
            break;
    }
    return 0;
}

循环语句

C++提供了多种循环语句，包括for、while和do-while。

• for循环：
  • 适用于已知循环次数。

#include <iostream>

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

• while循环：
  • 适用于不确定循环次数。

#include <iostream>

int main() {
    int i = 0;
    while (i < 5) {
        std::cout << "i: " << i << std::endl;
        ++i;
    }
    return 0;
}

• do-while循环：
  • 类似于while，但先执行循环体再判断条件。

#include <iostream>

int main() {
    int i = 0;
    do {
        std::cout << "i: " << i << std::endl;
        ++i;
    } while (i < 5);
    return 0;
}

函数定义与调用

C++函数可以用于封装代码，提升代码的可重用性。

• 函数定义：
  • 函数原型示例：

#include <iostream>

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

int main() {
    int result = add(5, 3);
    std::cout << "Result: " << result << std::endl;
    return 0;
}

• 默认参数：
  • 函数可以有默认参数值。

#include <iostream>

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

int main() {
    int result = add(5);
    std::cout << "Result: " << result << std::endl;
    return 0;
}

C++11中lambda表达式

C++11引入了lambda表达式，可以在代码中定义匿名函数。

• 基本形式：

#include <iostream>

int main() {
    auto func = [](int a, int b) {
        return a + b;
    };
    int result = func(5, 3);
    std::cout << "Result: " << result << std::endl;
    return 0;
}

• 捕获变量：

#include <iostream>

int main() {
    int a = 5;
    auto func = [a]() {
        return a + 1;
    };
    int result = func();
    std::cout << "Result: " << result << std::endl;
    return 0;
}

• 更详细的说明和实际应用案例：

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

int main() {
    std::vector<int> vec = {5, 3, 4, 2, 1};
    std::sort(vec.begin(), vec.end(), [](int a, int b) -> bool {
        return a > b;
    });
    for (int i : vec) {
        std::cout << i << std::endl;
    }
    return 0;
}

对象与类

类的定义与实例化

C++类是一种用户定义的数据类型，可以包含数据成员和成员函数。

• 类定义：

#include <iostream>

class Point {
public:
    int x;
    int y;

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

    void print() {
        std::cout << "Point: (" << x << ", " << y << ")" << std::endl;
    }
};

int main() {
    Point p(10, 20);
    p.print();
    return 0;
}

• 类的继承：

#include <iostream>

class Point {
public:
    int x;
    int y;

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

    void print() {
        std::cout << "Point: (" << x << ", " << y << ")" << std::endl;
    }
};

class ColorPoint : public Point {
public:
    std::string color;

    ColorPoint(int x, int y, std::string color) : Point(x, y), color(color) {}

    void print() {
        std::cout << "ColorPoint: (" << x << ", " << y << ") Color: " << color << std::endl;
    }
};

int main() {
    ColorPoint cp(10, 20, "Red");
    cp.print();
    return 0;
}

成员函数与成员变量

成员函数和成员变量是类的两个主要组成部分。

• 成员函数：
  • 成员函数可以访问私有成员变量。

#include <iostream>

class Point {
public:
    int x;
    int y;

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

    void setX(int newX) {
        x = newX;
    }

    int getX() {
        return x;
    }
};

int main() {
    Point p(10, 20);
    p.setX(15);
    std::cout << "X: " << p.getX() << std::endl;
    return 0;
}

• 私有成员变量：
  • 只能在类内部访问。

#include <iostream>

class Point {
private:
    int x;
    int y;

public:
    Point(int x, int y) : x(x), y(y) {}

    void setX(int newX) {
        x = newX;
    }

    int getX() {
        return x;
    }
};

int main() {
    Point p(10, 20);
    p.setX(15);
    std::cout << "X: " << p.getX() << std::endl;
    return 0;
}

构造函数与析构函数

构造函数用于初始化对象，析构函数用于清理对象。

• 构造函数：

#include <iostream>

class Point {
public:
    int x;
    int y;

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

    ~Point() {
        std::cout << "Point destructed" << std::endl;
    }
};

int main() {
    Point p(10, 20);
    return 0;
}

• 析构函数：

#include <iostream>

class Point {
public:
    int x;
    int y;

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

    ~Point() {
        std::cout << "Point destructed" << std::endl;
    }
};

int main() {
    Point p(10, 20);
    return 0;
}

C++11中的智能指针

C++11引入了智能指针，帮助管理动态分配的内存。

• std::unique_ptr：
  • 拥有资源的唯一指针。

#include <iostream>
#include <memory>

int main() {
    std::unique_ptr<int> p = std::make_unique<int>(10);
    *p = 15;
    std::cout << "*p: " << *p << std::endl;
    return 0;
}

• std::shared_ptr：
  • 多个指针共享资源。

#include <iostream>
#include <memory>

int main() {
    std::shared_ptr<int> p1 = std::make_shared<int>(10);
    std::shared_ptr<int> p2 = p1;
    *p1 = 15;
    std::cout << "*p1: " << *p1 << ", *p2: " << *p2 << std::endl;
    return 0;
}

• 更深入的解释和实际项目应用案例：

#include <iostream>
#include <memory>

int main() {
    std::unique_ptr<int> up = std::make_unique<int>(10);
    std::shared_ptr<int> sp = std::make_shared<int>(15);
    *up = 20;
    *sp = 25;
    std::cout << "*up: " << *up << ", *sp: " << *sp << std::endl;
    return 0;
}

标准模板库(STL)简介

容器

STL提供了多种容器，如vector、list、map等。

• vector：
  • 动态数组。

#include <iostream>
#include <vector>

int main() {
    std::vector<int> vec = {1, 2, 3, 4, 5};
    for (int i : vec) {
        std::cout << i << std::endl;
    }
    return 0;
}

• list：
  • 链表。

#include <iostream>
#include <list>

int main() {
    std::list<int> lst = {1, 2, 3, 4, 5};
    for (int i : lst) {
        std::cout << i << std::endl;
    }
    return 0;
}

• map：
  • 关联容器。

#include <iostream>
#include <map>

int main() {
    std::map<std::string, int> m = {{"one", 1}, {"two", 2}, {"three", 3}};
    for (const auto &p : m) {
        std::cout << p.first << ": " << p.second << std::endl;
    }
    return 0;
}

算法

STL提供了一组算法，如sort、find等。

• sort：
  • 对容器进行排序。

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

int main() {
    std::vector<int> vec = {5, 3, 2, 4, 1};
    std::sort(vec.begin(), vec.end());
    for (int i : vec) {
        std::cout << i << std::endl;
    }
    return 0;
}

• find：
  • 查找元素。

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

int main() {
    std::vector<int> vec = {1, 2, 3, 4, 5};
    auto it = std::find(vec.begin(), vec.end(), 3);
    if (it != vec.end()) {
        std::cout << "Found: " << *it << std::endl;
    }
    return 0;
}

迭代器

迭代器是访问容器元素的通用机制。

• begin和end：
  • 获取迭代器。

#include <iostream>
#include <vector>

int main() {
    std::vector<int> vec = {1, 2, 3, 4, 5};
    for (auto it = vec.begin(); it != vec.end(); ++it) {
        std::cout << *it << std::endl;
    }
    return 0;
}

C++11中新增容器与算法

C++11引入了一些新的容器和算法。

• std::unordered_map：
  • 无序关联容器。

#include <iostream>
#include <unordered_map>

int main() {
    std::unordered_map<std::string, int> um = {{"one", 1}, {"two", 2}, {"three", 3}};
    for (const auto &p : um) {
        std::cout << p.first << ": " << p.second << std::endl;
    }
    return 0;
}

• for范围循环：
  • 简化遍历容器。

#include <iostream>
#include <vector>

int main() {
    std::vector<int> vec = {1, 2, 3, 4, 5};
    for (int i : vec) {
        std::cout << i << std::endl;
    }
    return 0;
}

• std::unordered_set：
  • 无序集合容器。

#include <iostream>
#include <unordered_set>

int main() {
    std::unordered_set<int> us = {1, 2, 3, 4, 5};
    for (int i : us) {
        std::cout << i << std::endl;
    }
    return 0;
}

实践项目与常见问题解答

小项目实践：如简单的计算器

实现一个简单的计算器，支持加、减、乘、除运算。

• 代码示例：

#include <iostream>

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

int subtract(int a, int b) {
    return a - b;
}

int multiply(int a, int b) {
    return a * b;
}

int divide(int a, int b) {
    if (b == 0) {
        std::cout << "Error: Division by zero" << std::endl;
        return 0;
    }
    return a / b;
}

int main() {
    int a, b;
    std::cout << "Enter two numbers: ";
    std::cin >> a >> b;

    int sum = add(a, b);
    int difference = subtract(a, b);
    int product = multiply(a, b);
    int quotient = divide(a, b);

    std::cout << "Sum: " << sum << std::endl;
    std::cout << "Difference: " << difference << std::endl;
    std::cout << "Product: " << product << std::endl;
    std::cout << "Quotient: " << quotient << std::endl;

    return 0;
}

常见错误与调试技巧

调试是编程过程中不可或缺的一部分。

• 调试技巧：

  • 使用断点。
  • 使用std::cout打印变量值。
  • 使用IDE调试工具。
• 常见错误：
  • 未初始化变量。
  • 未释放内存。
  • 指针操作错误。

C++11特性在实际项目中的应用

C++11特性可以提升代码的清晰度和效率。

• 使用auto关键字：
  • 自动推断类型。

#include <iostream>

int main() {
    auto a = 5;
    std::cout << "a: " << a << std::endl;
    return 0;
}

• 使用lambda表达式：
  • 匿名函数。

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

int main() {
    std::vector<int> vec = {5, 3, 4, 2, 1};
    std::sort(vec.begin(), vec.end(), [](int a, int b) { return a > b; });
    for (int i : vec) {
        std::cout << i << std::endl;
    }
    return 0;
}

• 使用std::unique_ptr和std::shared_ptr：
  • 智能指针管理内存。

#include <iostream>
#include <memory>

int main() {
    std::unique_ptr<int> up = std::make_unique<int>(10);
    std::shared_ptr<int> sp = std::make_shared<int>(15);
    *up = 20;
    *sp = 25;
    std::cout << "*up: " << *up << ", *sp: " << *sp << std::endl;
    return 0;
}
``