C++11学习：从入门到初级实战教程

概述

本文介绍了C++11的新特性和基础语法，帮助读者快速入门c++11学习，涵盖了变量、运算符、控制结构和面向对象编程等内容。文章还详细讲解了标准库的使用方法，包括常用的容器类型和智能指针，并提供了实际编程中的示例和调试技巧。

C++11基础入门

C++语言简介

C++是一种静态类型、编译式的通用、程序化的编程语言。C++具有C语言的高效和低级操作能力，同时提供了面向对象编程的支持，包括类、继承、多态等特性。C++被广泛应用于系统软件、嵌入式系统、图形用户界面、游戏开发等多个领域。C++语言的诞生可以追溯到20世纪80年代，由Bjarne Stroustrup在贝尔实验室开发，它兼容C语言，但增加了面向对象的特性。

C++11新特性概览

C++11是C++语言的一个重要版本，引入了许多新特性，改进了旧有的语法，并提供了更强大的功能。主要的新特性包括：

1. 自动类型推断(auto关键字)：自动推断变量的类型。
2. 右值引用与移动语义：使得资源转移更为高效。
3. lambda表达式：使代码更加简洁，支持匿名函数。
4. 范围for循环：遍历容器更加方便。
5. 智能指针：提高内存管理的安全性。
6. 类型推断(decltype关键字)：推断表达式的类型。
7. 新的库特性：例如新的容器类型和算法。

这些特性使得C++11在编写高效、清晰的代码方面更为强大。

安装开发环境

安装C++开发环境需要以下几个步骤：

1. 安装编译器：最常用的编译器是GCC和Clang。对于Windows用户，MinGW和MSVC也是不错的选择。
2. 安装IDE或文本编辑器：集成开发环境如Visual Studio、Code::Blocks，或者文本编辑器如Vim、Sublime Text、VSCode等都可以。

以下是安装GCC和Clang在Ubuntu上的步骤：

1. 更新软件包列表：

   sudo apt-get update

2. 安装GCC和G++：

   sudo apt-get install gcc g++

3. 安装Clang：

   sudo apt-get install clang

代码编写与运行环境

编写代码示例

编写一个简单的"Hello, World!"程序：

#include <iostream>

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

编译与运行代码

使用GCC编译并运行代码：

g++ -o hello hello.cpp
./hello

或使用Clang：

clang++ -o hello hello.cpp
./hello

C++11基本语法

变量与数据类型

C++中，变量是存储数据的基本单元，通过声明变量可以定义其类型和名称。C++支持多种基本数据类型，包括整型、浮点型、字符型等。

声明变量示例

int a; // 整型变量
float b; // 浮点型变量
char c; // 字符型变量

初始化变量

直接在声明时初始化变量：

int a = 10;
float b = 3.14f;
char c = 'A';

其他类型

C++还支持其他类型，例如布尔型、长整型等。

bool isTrue = true;
long l = 1234567890;
unsigned int u = 10;

运算符

运算符用于执行算术、逻辑和位操作等任务。常见的运算符有算术运算符、逻辑运算符和位运算符等。

算术运算符

加法、减法、乘法、除法、取余等：

int a = 10, b = 5;
int sum = a + b;
int diff = a - b;
int prod = a * b;
int quot = a / b;
int rem = a % b;

逻辑运算符

逻辑与、逻辑或、逻辑非等：

bool x = true, y = false;
bool andResult = x && y;
bool orResult = x || y;
bool notResult = !x;

位运算符

位与、位或、位异或、位非等：

int x = 5; // 二进制为 0101
int y = 3; // 二进制为 0011
int andResult = x & y; // 0001
int orResult = x | y; // 0111
int xorResult = x ^ y; // 0110
int notResult = ~x; // -0110 (补码)

控制结构

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

if语句

int a = 10;
if (a > 5) {
    std::cout << "a is greater than 5" << std::endl;
}

switch语句

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;
}

循环语句

for循环

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

while循环

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

do-while循环

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

函数定义与调用

函数是完成特定功能的代码块，可以被多次调用。函数定义包括返回类型、函数名、参数列表和函数体。

函数定义

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

函数调用

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

C++11面向对象编程

类与对象

类是面向对象编程的基础，用于定义对象的结构和行为。类中包含成员变量和成员函数。

定义类

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

    void sayHello() {
        std::cout << "Hello, my name is " << name << " and I am " << age << " years old." << std::endl;
    }
};

创建对象

Person p;
p.name = "Alice";
p.age = 25;
p.sayHello();

构造函数与析构函数

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

构造函数

class Person {
public:
    std::string name;
    int age;
    Person(std::string n, int a) : name(n), age(a) {}
    void sayHello() {
        std::cout << "Hello, my name is " << name << " and I am " << age << " years old." << std::endl;
    }
};

Person p("Alice", 25);
p.sayHello();

析构函数

class Person {
public:
    std::string name;
    int age;
    Person(std::string n, int a) : name(n), age(a) {}
    ~Person() {
        std::cout << "Person object destroyed" << std::endl;
    }
    void sayHello() {
        std::cout << "Hello, my name is " << name << " and I am " << age << " years old." << std::endl;
    }
};

Person p("Alice", 25);
p.sayHello();

成员变量与成员函数

类中的成员变量和成员函数定义了类的属性和行为。

成员变量

class Person {
public:
    std::string name;
    int age;
    Person(std::string n, int a) : name(n), age(a) {}
    void sayHello() {
        std::cout << "Hello, my name is " << name << " and I am " << age << " years old." << std::endl;
    }
};

成员函数

class Person {
public:
    std::string name;
    int age;
    Person(std::string n, int a) : name(n), age(a) {}
    void sayHello() {
        std::cout << "Hello, my name is " << name << " and I am " << age << " years old." << std::endl;
    }
};

Person p("Alice", 25);
p.sayHello();

继承与多态

继承允许子类继承父类的属性和方法，多态允许在运行时动态选择方法。

继承

class Person {
public:
    std::string name;
    int age;
    Person(std::string n, int a) : name(n), age(a) {}
    void sayHello() {
        std::cout << "Hello, my name is " << name << " and I am " << age << " years old." << std::endl;
    }
};

class Student : public Person {
public:
    std::string studentID;
    Student(std::string n, int a, std::string id) : Person(n, a), studentID(id) {}
    void sayID() {
        std::cout << "My student ID is " << studentID << std::endl;
    }
};

Student s("Alice", 25, "12345");
s.sayHello();
s.sayID();

多态

#include <iostream>

class Animal {
public:
    virtual void speak() = 0; // 纯虚函数，使得Animal成为一个抽象基类
};

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

class Cat : public Animal {
public:
    void speak() override {
        std::cout << "Meow!" << std::endl;
    }
};

int main() {
    Dog d;
    Cat c;
    Animal *a1 = &d;
    Animal *a2 = &c;
    a1->speak();
    a2->speak();
    return 0;
}

C++11标准库使用

常用标准库容器及使用

C++标准库提供了多种容器类型，如vector、list、map等，用于管理和操作数据。

vector容器

vector是动态数组，支持随机访问。

#include <vector>
#include <iostream>

int main() {
    std::vector<int> vec;
    vec.push_back(1);
    vec.push_back(2);
    vec.push_back(3);
    for (int i : vec) {
        std::cout << i << std::endl;
    }
    return 0;
}

list容器

list是双向链表，支持插入和删除操作。

#include <list>
#include <iostream>

int main() {
    std::list<int> li;
    li.push_back(1);
    li.push_back(2);
    li.push_back(3);
    for (int i : li) {
        std::cout << i << std::endl;
    }
    return 0;
}

map容器

map是关联容器，用于存储键值对。

#include <map>
#include <iostream>

int main() {
    std::map<std::string, int> mp;
    mp["Alice"] = 25;
    mp["Bob"] = 30;
    for (const auto& kv : mp) {
        std::cout << kv.first << " : " << kv.second << std::endl;
    }
    return 0;
}

set容器

set容器是一种有序集合，不允许重复元素。

#include <set>
#include <iostream>

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

string与iostream库基础

string类

string类用于操作字符串，提供了丰富的字符串操作方法。

#include <string>
#include <iostream>

int main() {
    std::string str = "Hello, World!";
    std::cout << str << std::endl;
    str += " How are you?";
    std::cout << str << std::endl;
    return 0;
}

iostream类

iostream类用于输入输出流操作。

#include <iostream>

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

vector、map、set等容器介绍与实例

vector容器

#include <vector>
#include <iostream>

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

map容器

#include <map>
#include <iostream>

int main() {
    std::map<std::string, int> mp = {{"Alice", 25}, {"Bob", 30}};
    for (const auto& kv : mp) {
        std::cout << kv.first << " : " << kv.second << std::endl;
    }
    return 0;
}

set容器

#include <set>
#include <iostream>

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

C++11进阶特性

lambda表达式

lambda表达式是一种匿名函数，可以临时定义并立即使用。

基本用法

#include <iostream>

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

捕获外部变量

#include <iostream>

int main() {
    int x = 10;
    auto func = [x]() { std::cout << "x: " << x << std::endl; };
    func();
    return 0;
}

使用引用捕获

#include <iostream>

int main() {
    int x = 10;
    auto func = [&x]() { x = 20; };
    func();
    std::cout << "x: " << x << std::endl;
    return 0;
}

智能指针

智能指针是C++11引入的一种资源管理机制，可以自动管理内存释放。

shared_ptr

#include <memory>
#include <iostream>

int main() {
    std::shared_ptr<int> ptr = std::make_shared<int>(10);
    std::cout << *ptr << std::endl;
    return 0;
}

unique_ptr

#include <memory>
#include <iostream>

int main() {
    std::unique_ptr<int> ptr(new int(10));
    std::cout << *ptr << std::endl;
    return 0;
}

range-based for循环

range-based for循环可以遍历容器中的元素，简化代码。

#include <vector>
#include <iostream>

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

auto关键字

auto关键字用于自动推断变量的类型，简化代码。

#include <iostream>

int main() {
    auto x = 10;
    auto y = 3.14f;
    auto z = "Hello, World!";
    std::cout << x << std::endl;
    std::cout << y << std::endl;
    std::cout << z << std::endl;
    return 0;
}

decltype关键字

decltype关键字用于推断表达式的类型。

#include <iostream>

int main() {
    int x = 10;
    decltype(x) y = 20;
    std::cout << y << std::endl;
    return 0;
}

小结与实战项目

C++11编程实践

在实际编程中，C++11提供了更强大的语法和库支持，使得代码更加简洁和高效。例如，使用智能指针管理内存，使用lambda表达式简化代码，使用新的容器类型处理数据等。

示例：使用智能指针管理内存

#include <memory>
#include <iostream>

void function(std::shared_ptr<int> ptr) {
    *ptr = 20;
}

int main() {
    std::shared_ptr<int> ptr = std::make_shared<int>(10);
    function(ptr);
    std::cout << *ptr << std::endl;
    return 0;
}

示例：使用lambda表达式简化代码

#include <iostream>

int main() {
    int x = 10, y = 20;
    auto add = [](int a, int b) { return a + b; };
    std::cout << "Sum: " << add(x, y) << std::endl;
    return 0;
}

常见编程错误与调试技巧

在C++编程中，常见的错误包括内存泄漏、数组越界、指针错误等。调试技巧包括使用断点、打印调试信息、使用调试工具等。

示例：内存泄漏

#include <iostream>

int main() {
    int* ptr = new int(10);
    std::cout << *ptr << std::endl;
    // 忘记释放内存
    return 0;
}

调试技巧

使用调试工具如GDB进行调试：

g++ -g -o test test.cpp
gdb ./test

在GDB中使用命令进行调试：

break main
run
print *ptr

小项目案例分析与实现

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

这个计算器可以支持加法、减法、乘法、除法等基本运算。

代码实现

#include <iostream>
#include <string>
#include <map>

class Calculator {
public:
    double calculate(const std::string& expression) {
        std::map<std::string, double(*)(double, double)> ops = {
            {"+", add},
            {"-", subtract},
            {"*", multiply},
            {"/", divide}
        };

        double a, b;
        std::string op;
        std::istringstream iss(expression);
        iss >> a >> op >> b;

        if (ops.find(op) == ops.end()) {
            std::cerr << "Invalid operation" << std::endl;
            return 0;
        }

        return ops[op](a, b);
    }

private:
    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) { return a / b; }
};

int main() {
    Calculator calc;
    std::cout << "Result: " << calc.calculate("10 + 5") << std::endl;
    std::cout << "Result: " << calc.calculate("10 - 5") << std::endl;
    std::cout << "Result: " << calc.calculate("10 * 5") << std::endl;
    std::cout << "Result: " << calc.calculate("10 / 5") << std::endl;
    return 0;
}

运行结果

Result: 15
Result: 5
Result: 50
Result: 2

这个示例展示了如何使用C++11的特性，如map、lambda表达式等，实现一个简单的计算器程序。