C++11工程实践资料：新手入门教程

本文详细介绍了C++11语言的新特性和开发环境搭建方法，并提供了丰富的代码示例和实践案例。文章还涵盖了基础语法、面向对象编程以及标准库的使用，旨在帮助读者更好地理解和应用C++11工程实践资料。

C++11语言特性概述

C++11是C++语言的重要版本之一，它引入了许多新的特性和改进，使得C++代码更加简洁、安全和高效。以下是一些主要的新特性：

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

   auto x = 5;  // x 的类型为 int
   auto y = 3.14;  // y 的类型为 double

2. 范围for循环：可以方便地遍历容器中的元素。

   std::vector<int> vec = {1, 2, 3, 4, 5};
   for (auto& elem : vec) {
      std::cout << elem << " ";
   }

3. Lambda表达式：支持匿名函数，可以方便地编写短小的函数。

   auto lambda = [](int x) { return x * x; };
   int result = lambda(5);  // result 为 25

4. 右值引用和移动语义：提高了资源管理的效率。

   std::string str1 = "Hello";
   std::string str2 = std::move(str1);  // 移动 str1 的资源到 str2
   std::cout << str1 << std::endl;  // 输出为空

5. 智能指针：提供了更安全的指针管理方式。

   std::unique_ptr<int> ptr1(new int(10));
   std::unique_ptr<int> ptr2 = std::move(ptr1);

6. 类型别名：使用using关键字定义别名，简化类型声明。

   using FloatPair = std::pair<float, float>;
   FloatPair pair1(3.5f, 4.5f);

7. 初始化列表：支持统一的初始化方式，包括直接列表初始化。

   std::vector<int> vec = {1, 2, 3, 4, 5};

8. 线程支持库：内置了多线程编程的支持。

   std::thread t1([]() { std::cout << "线程1" << std::endl; });
   std::thread t2([]() { std::cout << "线程2" << std::endl; });
   t1.join();
   t2.join();

开发环境搭建指南

搭建C++开发环境通常需要以下几个步骤：

1. 安装编译器：选择适合的编译器，如GCC或Clang。
2. 安装开发库：安装必要的开发库和头文件。
3. 配置开发环境：配置IDE或编辑器，如Visual Studio Code、Sublime Text等。
4. 配置CMake或Makefile：用于构建和管理项目。

示例：在Linux环境下安装GCC

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

常用开发工具介绍

常用的C++开发工具包括：

1. IDE：如Visual Studio Code、CLion、Qt Creator等。
2. 编辑器：如Sublime Text、Vim、Emacs等。
3. 构建工具：如CMake、Make、Gradle等。
4. 版本控制工具：如Git、Mercurial等。

示例：在Visual Studio Code中配置C++

1. 安装Visual Studio Code。
2. 安装C++扩展。
3. 配置编译器路径和构建任务。

{
    "version": "2.0.0",
    "tasks": [
        {
            "label": "g++ build active file",
            "type": "shell",
            "command": "g++",
            "args": [
                "-std=c++11",
                "-g",
                "${file}",
                "-o",
                "${fileDirname}/${fileBasenameNoExtension}"
            ],
            "group": {
                "kind": "build",
                "isDefault": true
            },
            "problemMatcher": "$gcc"
        }
    ]
}

变量与常量

在C++中，变量是用来存储数据的容器，而常量则是不可修改的值。以下是变量和常量的基本用法。

变量定义

int main() {
    int age = 20;  // 整型变量
    double price = 19.99;  // 浮点型变量
    char grade = 'A';  // 字符变量
    bool is_valid = true;  // 布尔型变量
    std::string name = "Alice";  // 字符串变量
    return 0;
}

常量定义

const int MAX_SIZE = 100;  // 常量整型
constexpr double PI = 3.14159;  // 常量浮点型
const char* greeting = "Hello, World!";  // 指向常量的字符串指针

数据类型与转换

C++提供了多种基本数据类型，包括整型、浮点型、字符型等。数据类型之间可以进行转换。

数据类型转换

int num = 123;
double dnum = static_cast<double>(num);  // 整型转浮点型
int new_num = static_cast<int>(dnum);  // 浮点型转整型
char ch = 'A';
int ascii = static_cast<int>(ch);  // 字符转整型

常用运算符详解

C++中常用的运算符包括算术运算符、关系运算符、逻辑运算符等。

算术运算符

int a = 10;
int b = 5;
int sum = a + b;  // 加法
int diff = a - b;  // 减法
int prod = a * b;  // 乘法
int quo = a / b;  // 除法
int rem = a % b;  // 取余

关系运算符

int x = 10;
int y = 20;
bool result = x > y;  // 大于
result = x < y;  // 小于
result = x >= y;  // 大于等于
result = x <= y;  // 小于等于
result = x == y;  // 等于
result = x != y;  // 不等于

逻辑运算符

bool flag1 = true;
bool flag2 = false;
bool result = flag1 && flag2;  // 逻辑与
result = flag1 || flag2;  // 逻辑或
result = !flag1;  // 逻辑非

条件语句与循环结构

控制结构用于控制程序的执行流程，包括条件语句和循环结构。

if语句

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

switch语句

int num = 2;
switch (num) {
    case 1:
        std::cout << "数字1" << std::endl;
        break;
    case 2:
        std::cout << "数字2" << std::endl;
        break;
    default:
        std::cout << "其他数字" << std::endl;
}

while循环

int i = 0;
while (i < 10) {
    std::cout << i << " ";
    i++;
}

for循环

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

do-while循环

int i = 0;
do {
    std::cout << i << " ";
    i++;
} while (i < 10);

函数定义与调用

函数是C++程序的基本构建块，用于封装可重用的代码。

函数定义

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

函数调用

int result = add(5, 7);
std::cout << "结果: " << result << std::endl;

参数传递与返回值

参数传递可以是值传递、引用传递和指针传递。

值传递

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

引用传递

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

指针传递

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

返回值

int get_value() {
    return 42;
}

类与对象

类是对象的蓝图，对象是类的实例。类通常包含数据成员和成员函数。

定义类

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

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

创建对象

int main() {
    Person p;
    p.name = "Alice";
    p.age = 25;
    p.display_info();
    return 0;
}

成员函数与数据成员

成员函数用于操作数据成员，可以实现对象的功能。

成员函数

class Rectangle {
public:
    int width;
    int height;

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

数据成员

int main() {
    Rectangle r;
    r.width = 10;
    r.height = 20;
    std::cout << "面积: " << r.area() << std::endl;
    return 0;
}

继承与多态

继承允许一个类继承另一个类的属性和方法，多态允许对象通过不同的方式表现。

继承

class Animal {
public:
    void speak() {
        std::cout << "动物发声" << std::endl;
    }
};

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

多态

void make_speak(Animal& a) {
    a.speak();
}

int main() {
    Animal a;
    Dog d;
    make_speak(a);  // 输出: 动物发声
    make_speak(d);  // 输出: 狗吠
    return 0;
}

常用标准库概述

C++标准库提供了丰富的功能，包括容器、算法、迭代器等。

标准库容器

• vector：动态数组。
• list：双向链表。
• map：关联容器，键值对。
• set：集合容器，自动排序。
• queue：队列容器。
• stack：栈容器。

示例代码

#include <iostream>
#include <vector>
#include <list>
#include <map>
#include <set>
#include <queue>
#include <stack>

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

    std::list<int> lst = {10, 20, 30, 40, 50};
    for (int i : lst) {
        std::cout << i << " ";
    }
    std::cout << std::endl;

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

    std::set<int> s = {100, 200, 300, 400, 500};
    for (int i : s) {
        std::cout << i << " ";
    }
    std::cout << std::endl;

    std::queue<int> q;
    q.push(1);
    q.push(2);
    q.push(3);
    while (!q.empty()) {
        std::cout << q.front() << " ";
        q.pop();
    }
    std::cout << std::endl;

    std::stack<int> stk;
    stk.push(1);
    stk.push(2);
    stk.push(3);
    while (!stk.empty()) {
        std::cout << stk.top() << " ";
        stk.pop();
    }
    std::cout << std::endl;

    return 0;
}

容器的使用方法

容器提供了多种方法用于操作和管理数据。

vector

std::vector<int> vec;
vec.push_back(1);
vec.push_back(2);
vec.push_back(3);
vec.pop_back();
vec.insert(vec.begin(), 0);
vec.erase(vec.begin() + 1);

list

std::list<int> lst;
lst.push_back(1);
lst.push_back(2);
lst.push_back(3);
lst.pop_back();
lst.insert(lst.begin(), 0);
lst.erase(lst.begin() + 1);

map

std::map<int, std::string> m;
m[1] = "one";
m[2] = "two";
m.erase(1);

set

std::set<int> s;
s.insert(1);
s.insert(2);
s.insert(3);
s.erase(1);

算法与迭代器简介

C++标准库提供了丰富的算法和迭代器，用于操作容器中的数据。

算法

std::vector<int> vec = {1, 2, 3, 4, 5};
std::sort(vec.begin(), vec.end());
std::for_each(vec.begin(), vec.end(), [](int& i) { i *= 2; });

迭代器

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

简单项目的开发流程

开发一个简单的C++项目通常包括以下几个步骤：

1. 需求分析：明确项目的目标和需求。
2. 设计：设计项目的结构和模块。
3. 编码：编写代码实现设计。
4. 调试：调试和测试代码。
5. 部署：将项目部署到目标环境。
6. 维护：维护和更新项目。

示例：实现一个简单的计算器

1. 需求分析：实现一个简单的四则运算计算器。
2. 设计：设计类和函数。
3. 编码：编写代码实现设计。
4. 调试：调试代码并确保正确性。
5. 部署：编译并运行程序。
6. 维护：修复可能出现的问题。

示例代码

#include <iostream>
#include <string>

class Calculator {
public:
    double add(double a, double b) {
        return a + b;
    }

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

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

    double divide(double a, double b) {
        if (b == 0) {
            std::cout << "除数不能为0" << std::endl;
            return 0;
        }
        return a / b;
    }
};

int main() {
    Calculator calc;
    std::string operation;
    double num1, num2;

    while (true) {
        std::cout << "请输入操作符（+、-、*、/）：";
        std::cin >> operation;
        if (operation == "exit") break;

        std::cout << "请输入两个数字：";
        std::cin >> num1 >> num2;

        if (operation == "+") {
            std::cout << "结果：" << calc.add(num1, num2) << std::endl;
        } else if (operation == "-") {
            std::cout << "结果：" << calc.subtract(num1, num2) << std::endl;
        } else if (operation == "*") {
            std::cout << "结果：" << calc.multiply(num1, num2) << std::endl;
        } else if (operation == "/") {
            std::cout << "结果：" << calc.divide(num1, num2) << std::endl;
        } else {
            std::cout << "无效的操作符" << std::endl;
        }
    }

    return 0;
}

常见错误与调试技巧

在开发过程中，常见的错误包括语法错误、逻辑错误和运行时错误。调试技巧包括打印调试、断点调试和单元测试。

打印调试

std::cout << "值为：" << value << std::endl;

断点调试

使用IDE的断点调试功能，可以逐步执行代码并观察变量的变化。

单元测试

编写测试用例，确保代码的正确性。

#include <gtest/gtest.h>

class CalculatorTest : public ::testing::Test {
protected:
    Calculator calc;
};

TEST_F(CalculatorTest, AddTest) {
    EXPECT_EQ(calc.add(1, 2), 3);
}

TEST_F(CalculatorTest, SubtractTest) {
    EXPECT_EQ(calc.subtract(3, 1), 2);
}

TEST_F(CalculatorTest, MultiplyTest) {
    EXPECT_EQ(calc.multiply(2, 3), 6);
}

TEST_F(CalculatorTest, DivideTest) {
    EXPECT_EQ(calc.divide(6, 3), 2);
}

int main(int argc, char **argv) {
    ::testing::InitGoogleTest(&argc, argv);
    return RUN_ALL_TESTS();
}

实战案例解析

案例一：实现一个多线程的服务器

#include <iostream>
#include <thread>
#include <vector>
#include <mutex>

std::mutex mtx;

void worker(int id) {
    for (int i = 0; i < 5; i++) {
        std::lock_guard<std::mutex> guard(mtx);
        std::cout << "线程 " << id << " 执行任务 " << i << std::endl;
    }
}

int main() {
    std::vector<std::thread> threads;
    for (int i = 0; i < 5; i++) {
        threads.push_back(std::thread(worker, i));
    }

    for (auto& thread : threads) {
        thread.join();
    }

    return 0;
}

案例二：设计一个简单的数据库接口

#include <iostream>
#include <vector>
#include <string>

class Database {
public:
    void addRecord(const std::string& record) {
        records.push_back(record);
    }

    void printRecords() {
        std::cout << "记录：" << std::endl;
        for (const auto& record : records) {
            std::cout << record << std::endl;
        }
    }

private:
    std::vector<std::string> records;
};

int main() {
    Database db;
    db.addRecord("记录1");
    db.addRecord("记录2");
    db.printRecords();

    return 0;
}

通过以上案例，可以更好地理解和应用C++11中的新特性和标准库，提高编程效率和代码质量。