C++11学习：新手入门教程

概述

本文介绍了C++11的新特性和安装环境，包括新语法特性、标准库以及智能指针的使用。文章还详细讲解了如何在Visual Studio和Code::Blocks中搭建C++11开发环境，并提供了基础语法入门和新特性的示例代码。通过这些内容，读者可以全面了解C++11学习的关键点和实践方法。C++11学习涉及从基础语法到高级特性的全面覆盖，帮助程序员提升编程技能。

C++11简介与安装环境 C++11新特性介绍

C++11是C++编程语言的一个重要版本，该版本于2011年正式发布。相比之前的C++版本，C++11引入了许多新的功能和特性，使得编程更加简洁、安全和高效。

• 新的数据类型：引入了新的数据类型，如long long、constexpr和nullptr。
• 新的语法特性：支持auto关键字、range-based for循环、lambda表达式等。
• 新的标准库：引入了<chrono>、<thread>等新库，支持更强大的标准库函数。
• 智能指针：增加了std::unique_ptr和std::shared_ptr，提高了内存管理的安全性。
• 右值引用：引入了右值引用，使得移动语义和完美转发成为可能。
• 新的容器和算法：提供了更多的算法和容器，如std::unordered_map。

这些特性增强了C++语言的功能性和安全性，使得编程更加灵活和高效。

开发环境搭建

Visual Studio

Microsoft Visual Studio是C++编程一个常用的开发环境。以下是安装步骤：

1. 下载Visual Studio：
   访问Visual Studio下载页面，选择适合你的版本并下载安装。

2. 安装C++开发套件：
   启动Visual Studio安装程序，选择“自定义安装”。
   点击“工作负载”，选择“使用C++的桌面开发”。

3. 设置C++11支持：
   在Visual Studio中创建一个新的C++项目，确保选择了C++11或更高版本的编译器。在项目属性中，将"C/C++ -> 语言"的“C++语言标准”设置为iso c++11 standard with gibec。

Code::Blocks

Code::Blocks是一个开源且免费的集成开发环境（IDE），适用于多种编程语言，包括C++。以下是安装步骤：

1. 下载Code::Blocks：
   访问Code::Blocks官网，下载最新版本。

2. 安装Code::Blocks：
   安装程序向导中，选择适合你的安装选项，点击“下一步”，直到安装完成。

3. 配置C++11支持：
   在Code::Blocks中，选择“设置”->“编译器和构建”->“设置”->“全局编译器设置”。在“语言标准”选项中选择C++11。

编译与运行第一个C++11程序

C++11程序示例

#include <iostream>
using namespace std;

int main() {
    cout << "Hello, C++11!" << endl;
    return 0;
}

编译与运行

Visual Studio：

1. 在Visual Studio中创建一个新的C++项目。
2. 将上述代码复制到main.cpp文件中。
3. 点击工具栏上的“开始”按钮（绿色三角形）运行程序。

Code::Blocks：

1. 在Code::Blocks中创建一个新的C++项目。
2. 将上述代码复制到main.cpp文件中。
3. 右键点击项目，选择“编译”，然后选择“运行”运行程序。

---

基础语法入门 数据类型与变量

在C++中，变量用于存储数据，每种变量都有特定的数据类型。C++支持多种基本数据类型，包括整型、浮点型、字符型等。

整型

整型数据类型用于存储整数，包括不同大小和符号的整数。

• int：通常是32位有符号整数。
• short：通常为16位有符号整数。
• long：通常是32位或64位有符号整数，具体取决于平台。
• long long：64位有符号整数。

int a = 10;
short b = 5;
long c = 100000L;
long long d = 9223372036854775807LL;

浮点型

浮点型数据类型用于存储小数。

• float：单精度浮点数（约7位有效数字）。
• double：双精度浮点数（约15位有效数字）。
• long double：扩展精度浮点数。

float f = 3.14f;
double d = 3.14159;
long double ld = 3.14159265359L;

字符型

字符型数据类型用于存储单个字符。

• char：单个字符，通常是8位。
• wchar_t：宽字符，通常用于多字节字符集。

char ch = 'A';
wchar_t wc = L'B';

布尔型

布尔型数据类型用于存储逻辑值，只有两种可能的值：true 和 false。

bool flag = true;

示例代码

#include <iostream>
using namespace std;

int main() {
    int a = 10;
    short b = 5;
    long c = 100000L;
    long long d = 9223372036854775807LL;
    float f = 3.14f;
    double d1 = 3.14159;
    long double ld = 3.14159265359L;
    char ch = 'A';
    wchar_t wc = L'B';
    bool flag = true;

    cout << "整型变量： " << a << ", " << b << ", " << c << ", " << d << endl;
    cout << "浮点型变量： " << f << ", " << d1 << ", " << ld << endl;
    cout << "字符型变量： " << ch << ", " << wc << endl;
    cout << "布尔型变量： " << flag << endl;

    return 0;
}

基本运算符

在C++中，运算符用于执行各种操作，包括算术运算、逻辑运算、位运算等。

算术运算符

• +：加法
• -：减法
• *：乘法
• /：除法
• %：取模（取余）

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 flag1 = true;
bool flag2 = false;

bool logic_and = flag1 && flag2;
bool logic_or = flag1 || flag2;
bool logic_not = !flag1;

位运算符

• &：按位与
• |：按位或
• ^：按位异或
• ~：按位取反
• <<：左移
• >>：右移

int a = 5;  // 二进制：0101
int b = 3;  // 二进制：0011

int bitwise_and = a & b;     // 0001
int bitwise_or = a | b;      // 0111
int bitwise_xor = a ^ b;     // 0110
int bitwise_not = ~a;        // -6 (二进制：1010)
int bitwise_left_shift = a << 2; // 010100
int bitwise_right_shift = a >> 1; // 0010

代码示例

#include <iostream>
using namespace std;

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;

    cout << "加法结果: " << sum << endl;
    cout << "减法结果: " << difference << endl;
    cout << "乘法结果: " << product << endl;
    cout << "除法结果: " << quotient << endl;
    cout << "取模结果: " << remainder << endl;

    bool flag1 = true;
    bool flag2 = false;

    bool logic_and = flag1 && flag2;
    bool logic_or = flag1 || flag2;
    bool logic_not = !flag1;

    cout << "逻辑与: " << logic_and << endl;
    cout << "逻辑或: " << logic_or << endl;
    cout << "逻辑非: " << logic_not << endl;

    int bitwise_and = a & b;
    int bitwise_or = a | b;
    int bitwise_xor = a ^ b;
    int bitwise_not = ~a;
    int bitwise_left_shift = a << 2;
    int bitwise_right_shift = a >> 1;

    cout << "按位与: " << bitwise_and << endl;
    cout << "按位或: " << bitwise_or << endl;
    cout << "按位异或: " << bitwise_xor << endl;
    cout << "按位取反: " << bitwise_not << endl;
    cout << "左移: " << bitwise_left_shift << endl;
    cout << "右移: " << bitwise_right_shift << endl;

    return 0;
}

控制结构

C++中的控制结构包括if、switch、for和while等语句，用于控制程序的流程。

if语句

if语句用于执行条件判断，基于条件的真假决定是否执行特定的代码块。

if (条件) {
    // 条件为真时执行的代码
} else {
    // 条件为假时执行的代码
}

示例代码

#include <iostream>
using namespace std;

int main() {
    int num = 10;

    if (num > 5) {
        cout << "num大于5" << endl;
    } else {
        cout << "num不大于5" << endl;
    }

    return 0;
}

switch语句

switch语句用于执行多个可能的选择之一，基于不同的条件。

switch (表达式) {
    case 常量1:
        // 代码块1
        break;
    case 常量2:
        // 代码块2
        break;
    default:
        // 默认代码块
}

示例代码

#include <iostream>
using namespace std;

int main() {
    int num = 2;

    switch (num) {
        case 1:
            cout << "num是1" << endl;
            break;
        case 2:
            cout << "num是2" << endl;
            break;
        default:
            cout << "num是其他值" << endl;
    }

    return 0;
}

for循环

for循环用于重复执行一段代码，直到满足特定条件。

for (初始化; 条件; 更新) {
    // 循环体
}

示例代码

#include <iostream>
using namespace std;

int main() {
    for (int i = 1; i <= 5; ++i) {
        cout << "当前循环次数：" << i << endl;
    }

    return 0;
}

while循环

while循环用于重复执行一段代码，直到条件不再为真。

while (条件) {
    // 循环体
}

示例代码

#include <iostream>
using namespace std;

int main() {
    int i = 1;
    while (i <= 5) {
        cout << "当前循环次数：" << i << endl;
        ++i;
    }

    return 0;
}

do-while循环

do-while循环类似于while循环，但首先执行循环体，然后检查条件。

do {
    // 循环体
} while (条件);

示例代码

#include <iostream>
using namespace std;

int main() {
    int i = 1;
    do {
        cout << "当前循环次数：" << i << endl;
        ++i;
    } while (i <= 5);

    return 0;
}

代码示例

#include <iostream>
using namespace std;

int main() {
    int num = 10;

    if (num > 5) {
        cout << "num大于5" << endl;
    } else {
        cout << "num不大于5" << endl;
    }

    int num2 = 2;

    switch (num2) {
        case 1:
            cout << "num2是1" << endl;
            break;
        case 2:
            cout << "num2是2" << endl;
            break;
        default:
            cout << "num2是其他值" << endl;
    }

    for (int i = 1; i <= 5; ++i) {
        cout << "for循环次数：" << i << endl;
    }

    int j = 1;
    while (j <= 5) {
        cout << "while循环次数：" << j << endl;
        ++j;
    }

    int k = 1;
    do {
        cout << "do-while循环次数：" << k << endl;
        ++k;
    } while (k <= 5);

    return 0;
}

---

函数与指针 函数定义与调用

在C++中，函数用于封装可复用的代码块，可以通过函数名调用该代码块。

函数定义

函数定义包括函数名、返回类型、参数列表和函数体。

返回类型 函数名(参数列表) {
    // 函数体
    return 返回值;
}

函数调用

调用函数时，需要提供相应的参数，然后程序会执行函数体中的代码。

int result = 函数名(参数);

示例代码

#include <iostream>
using namespace std;

// 函数定义
int add(int a, int b) {
    return a + b;
}

int main() {
    // 函数调用
    int sum = add(3, 5);

    cout << "结果：" << sum << endl;

    return 0;
}

返回值与参数传递

返回值

函数可以返回一个值，返回值类型需要在函数定义中指定。返回值可以用于后续的计算或赋值。

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

参数传递

参数可以通过值传递或引用传递。值传递是将参数的副本传递给函数，而引用传递则是直接将参数传递给函数。

void increment(int& val) {
    ++val;
}

void increment_by_value(int val) {
    ++val;
}

示例代码

#include <iostream>
using namespace std;

// 通过值传递
void increment_by_value(int val) {
    ++val;
}

// 通过引用传递
void increment(int& val) {
    ++val;
}

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

int main() {
    int x = 5;
    int y = 5;

    // 通过值传递
    increment_by_value(x);

    // 通过引用传递
    increment(y);

    cout << "通过值传递：" << x << endl;
    cout << "通过引用传递：" << y << endl;

    int sum = add(3, 5);
    cout << "结果：" << sum << endl;

    return 0;
}

指针与引用

指针

指针是指向内存地址的变量，可以用来存储变量的地址。

int* ptr;
ptr = &x;
*ptr = 10;

引用

引用是变量的别名，引用必须在声明时初始化。

int& ref = x;
ref = 10;

示例代码

#include <iostream>
using namespace std;

int main() {
    int x = 5;

    // 指针
    int* ptr = &x;
    *ptr = 10;

    // 引用
    int& ref = x;
    ref = 15;

    cout << "通过指针：" << x << endl;
    cout << "通过引用：" << x << endl;

    return 0;
}

---

数组与字符串 数组的基本使用

数组是一组相同类型的元素的集合，可以通过下标访问数组中的元素。

定义数组

int arr[5] = {1, 2, 3, 4, 5};

访问数组元素

int first = arr[0];
arr[0] = 10;

示例代码

#include <iostream>
using namespace std;

int main() {
    int arr[5] = {1, 2, 3, 4, 5};

    // 访问数组元素
    cout << "第一个元素：" << arr[0] << endl;

    // 修改数组元素
    arr[0] = 10;
    cout << "修改后的第一个元素：" << arr[0] << endl;

    return 0;
}

字符串处理

字符串是一组字符的集合，可以用字符数组或std::string类表示。

字符数组

char str[10] = "Hello";

使用std::string类

std::string是C++标准库提供的字符串类，提供了丰富的字符串操作方法。

#include <string>
using namespace std;

string str = "Hello";

示例代码

#include <iostream>
#include <string>
using namespace std;

int main() {
    char str1[10] = "Hello";

    // 字符数组
    cout << "字符数组：" << str1 << endl;

    // std::string
    string str2 = "Hello";
    str2 += " World";

    cout << "std::string：" << str2 << endl;

    return 0;
}

使用标准库中的string类

std::string类提供了多种方法来处理字符串，例如拼接、截取、查找等。

拼接字符串

#include <string>

std::string str = "Hello";
str += " World";

截取字符串

#include <string>

std::string str = "Hello World";
std::string sub = str.substr(6, 5);

查找字符串

#include <string>

std::string str = "Hello World";
size_t pos = str.find("World");

示例代码

#include <iostream>
#include <string>
using namespace std;

int main() {
    string str = "Hello";

    // 拼接字符串
    str += " World";
    cout << "拼接后的字符串：" << str << endl;

    // 截取字符串
    string sub = str.substr(6, 5);
    cout << "截取的字符串：" << sub << endl;

    // 查找字符串
    size_t pos = str.find("World");
    if (pos != string::npos) {
        cout << "找到World的位置：" << pos << endl;
    } else {
        cout << "未找到World" << endl;
    }

    return 0;
}

---

结构体与类（面向对象编程基础） 结构体的定义与使用

结构体是一种复合数据类型，可以包含多个不同类型的数据成员。

定义结构体

struct Point {
    int x;
    int y;
};

访问结构体成员

Point p;
p.x = 10;
p.y = 20;

示例代码

#include <iostream>
using namespace std;

struct Point {
    int x;
    int y;
};

int main() {
    Point p;
    p.x = 10;
    p.y = 20;

    cout << "坐标：(" << p.x << ", " << p.y << ")" << endl;

    return 0;
}

类的定义与成员函数

类是一种用户自定义的数据类型，可以包含数据成员和成员函数。成员函数用于操作类的数据成员。

定义类

class Rectangle {
    int width;
    int height;

public:
    void setDimensions(int w, int h);
    int area();
};

成员函数实现

void Rectangle::setDimensions(int w, int h) {
    width = w;
    height = h;
}

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

示例代码

#include <iostream>
using namespace std;

class Rectangle {
    int width;
    int height;

public:
    void setDimensions(int w, int h);
    int area();
};

void Rectangle::setDimensions(int w, int h) {
    width = w;
    height = h;
}

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

int main() {
    Rectangle rect;
    rect.setDimensions(10, 5);
    cout << "面积：" << rect.area() << endl;

    return 0;
}

封装、继承与多态基础

封装

封装是将数据和操作数据的函数结合在一起，隐藏实现细节，对外提供统一的接口。

class Person {
private:
    string name;

public:
    void setName(string n);
    string getName();
};

void Person::setName(string n) {
    name = n;
}

string Person::getName() {
    return name;
}

继承

继承允许一个类继承另一个类的属性和方法，形成层次结构。

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

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

多态

多态允许不同对象对同一消息作出不同的响应，通过继承和虚函数实现。

class Shape {
public:
    virtual void draw() = 0;
};

class Circle : public Shape {
public:
    void draw() override {
        cout << "Drawing a circle." << endl;
    }
};

class Square : public Shape {
public:
    void draw() override {
        cout << "Drawing a square." << endl;
    }
};

示例代码

#include <iostream>
using namespace std;

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

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

int main() {
    Dog dog;
    dog.makeSound();

    return 0;
}

---

C++11新特性详解 智能指针

智能指针是一种可以自动管理内存的指针，主要类型包括std::unique_ptr和std::shared_ptr。

std::unique_ptr

std::unique_ptr是独占所有权的智能指针，确保只有一个unique_ptr可以持有给定的对象。

#include <memory>

std::unique_ptr<int> ptr = std::make_unique<int>(10);

std::shared_ptr

std::shared_ptr允许多个指针共享一个对象的所有权，当最后一个shared_ptr销毁时，对象也会被销毁。

#include <memory>

std::shared_ptr<int> ptr1 = std::make_shared<int>(10);
std::shared_ptr<int> ptr2 = ptr1;

示例代码

#include <iostream>
#include <memory>
using namespace std;

int main() {
    // unique_ptr示例
    std::unique_ptr<int> uniquePtr = std::make_unique<int>(10);
    cout << "unique_ptr的值：" << *uniquePtr << endl;

    // shared_ptr示例
    std::shared_ptr<int> sharedPtr1 = std::make_shared<int>(10);
    std::shared_ptr<int> sharedPtr2 = sharedPtr1;

    cout << "shared_ptr1的值：" << *sharedPtr1 << endl;
    cout << "shared_ptr2的值：" << *sharedPtr2 << endl;

    return 0;
}

auto关键字

auto关键字可以自动推断变量的类型，简化了代码的编写。

auto var = 10;
auto str = std::string("Hello");

示例代码

#include <iostream>
#include <string>
using namespace std;

int main() {
    auto var = 10;
    auto str = std::string("Hello");

    cout << "变量类型：" << typeid(var).name() << endl;
    cout << "字符串：" << str << endl;

    return 0;
}

range-based for循环

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

for (int elem : vec) {
    // 处理elem
}

示例代码

#include <iostream>
#include <vector>
using namespace std;

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

    for (int elem : vec) {
        cout << "元素：" << elem << endl;
    }

    return 0;
}

lambda表达式与函数对象

lambda表达式是一种匿名函数，可以方便地定义小型函数。

auto lambda = [](int a, int b) {
    return a + b;
};

示例代码

#include <iostream>
using namespace std;

int main() {
    auto lambda = [](int a, int b) {
        return a + b;
    };

    cout << "结果：" << lambda(3, 5) << endl;

    return 0;
}

---

总结：以上是C++11的基础知识、新特性和示例代码的详细介绍。希望这些内容可以帮助你更好地理解和使用C++11。如果你想进一步学习和实践，可以访问慕课网获得更多资源。