首页手记 C++11教程：新手入门与基础实践

C++11教程：新手入门与基础实践

标签：

C++

概述

本文详细介绍了C++11教程中的新特性和改进，包括类型推断、范围for循环、智能指针等。通过安装和配置开发环境，读者可以开始编写C++11代码。文章还涵盖了基本语法入门，如变量、数据类型、运算符和控制语句。最后，提供了实践项目和常见问题解决方案，帮助读者深入理解和应用C++11教程中的知识点。

C++11简介

C++11新特性概览

C++11是C++编程语言的一个重要版本，于2011年发布。它引入了许多新特性，旨在提高代码的可读性、可维护性和性能。以下是一些C++11的主要新特性：

类型推断：使用auto关键字可以自动推断变量的类型，减少了显式类型声明的需要。
范围for循环：简化了数组和容器的遍历。
右值引用：允许更高效的移动语义和完美转发。
lambda表达式：提供内联匿名函数的定义和使用。
初始化器列表：允许使用统一的初始化语法初始化对象。
智能指针：引入了std::unique_ptr和std::shared_ptr等智能指针，简化了内存管理。
新库功能：增加了对正则表达式、线程库和随机数生成器的支持。

C++11与旧版本对比

C++11相对于之前的C++版本（如C++98和C++03）做了许多改进。以下是一些关键的对比点：

类型推断：在旧版本中，必须显式声明变量的类型。例如：
```
int a = 10;  // 在C++11之前，需要显式声明类型
```
在C++11中，可以使用auto关键字自动推断类型：
```
auto a = 10;  // 类型推断
```
初始化器列表：在旧版本中，初始化容器时需要使用new和delete。例如：
```
int arr[5] = {1, 2, 3, 4, 5};
```
在C++11中，可以使用统一的初始化语法：
```
std::vector<int> vec = {1, 2, 3, 4, 5};
```
智能指针：旧版本没有提供内置的智能指针支持，需要手动管理内存。例如：
```
int* ptr = new int(10);
delete ptr;
```
在C++11中，可以使用std::unique_ptr：
```
std::unique_ptr<int> ptr(new int(10));
```

安装与配置开发环境

安装编译器

安装C++编译器是开发C++程序的第一步。以下是安装几种常见编译器的方法：

GCC（GNU Compiler Collection）

GCC是广泛使用的开源编译器。在Linux和MacOS上通常已经预装，如果未安装，可以通过包管理器安装：

Linux：
```
sudo apt-get install g++
```
MacOS：
```
brew install gcc
```

Clang

Clang是另一个流行的C++编译器，通常安装在MacOS上。如果未安装，可以通过brew安装：

brew install clang

Visual Studio

Visual Studio是Microsoft提供的集成开发环境（IDE），包含编译器。可以通过Microsoft官网下载安装：

https://visualstudio.microsoft.com/download/

配置集成开发环境（IDE）

配置集成开发环境（IDE）可以极大地提高开发效率。以下是一些常用的IDE：

Visual Studio Code

Visual Studio Code是一个轻量级、高度可定制的代码编辑器，支持多种语言，包括C++。可以通过以下步骤安装和配置：

下载并安装Visual Studio Code：
```
https://code.visualstudio.com/download
```
安装C++扩展：

在Visual Studio Code中打开扩展市场，搜索并安装“C/C++”扩展。
配置编译器路径：

打开设置，找到“C_Cpp > C_Cpp Compiler Path”，设置为你的编译器路径。
配置任务：

通过命令“Tasks: Configure Build Tasks”配置构建任务。

CLion

CLion是JetBrains开发的面向C/C++开发者的IDE。可以通过以下步骤安装和配置：

下载并安装CLion：

https://www.jetbrains.com/clion/download/

配置项目：

打开CLion，选择“File > New > C/C++ Project”创建新项目。
配置编译器：

打开设置，找到“Build, Execution, Deployment > Toolchains”，选择适当的编译器。

Visual Studio

Visual Studio是一个强大的IDE，适合C++开发。可以通过以下步骤安装和配置：

下载并安装Visual Studio：
```
https://visualstudio.microsoft.com/
```
安装C++工作负载：

在安装Visual Studio时，选择“C++”工作负载。
创建新项目：

打开Visual Studio，选择“File > New > Project”，选择“C++ Console App”，并配置项目设置。

基本语法入门

变量与数据类型

变量是程序中最基本的元素，用于存储数据。C++提供了多种数据类型，包括基本类型和复杂类型。

基本类型

C++的基本类型包括整型（int, short, long, long long）、浮点型（float, double, long double）、字符型（char, wchar_t）和布尔型（bool）。

整型

int a = 10;   // 整型
short b = 20; // 短整型
long c = 30;  // 长整型
long long d = 40;  // 长长整型

浮点型

float f = 1.234f; // 浮点型
double d = 1.23456789; // 双精度浮点型
long double ld = 1.2345678910111213; // 长双精度浮点型

字符型

char ch = 'a'; // 字符型
wchar_t wch = L'W'; // 宽字符型

布尔型

bool isTrue = true; // 布尔型
bool isFalse = false; // 布尔型

复杂类型

C++还提供了复杂类型，如数组、指针、结构体、联合体等。

数组

int arr[5] = {1, 2, 3, 4, 5}; // 整型数组
char str[10] = "Hello"; // 字符数组

指针

int* ptr = &a; // 整型指针
char* cptr = &ch; // 字符指针

基本运算符

运算符是C++中用于执行常见操作的符号。它们可以用于变量和常量的运算。

算术运算符

C++支持基本的算术运算符，包括加法（+）、减法（-）、乘法（*）、除法（/）和取模（%）。

int a = 10, b = 20;
int sum = a + b;   // 30
int diff = a - b;  // -10
int prod = a * b;  // 200
int quot = b / a;  // 2
int mod = b % a;   // 0

位运算符

位运算符用于对变量的位进行操作，包括按位与（&）、按位或（|）、按位异或（^）、按位取反（~）、左移（<<）和右移（>>）。

int a = 5;  // 二进制表示为 0101
int b = 3;  // 二进制表示为 0011

int andResult = a & b;  // 0001
int orResult = a | b;   // 0111
int xorResult = a ^ b;  // 0110
int notResult = ~a;     // 1010 (取决于补码)
int leftShiftResult = a << 1; // 1010
int rightShiftResult = a >> 1; // 0010

关系运算符

关系运算符用于比较两个操作数的关系，包括大于（>）、小于（<）、等于（==）、不等于（!=）、大于等于（>=）和小于等于（<=）。

int a = 10, b = 20;
bool isGreaterThan = (a > b);  // false
bool isLessThan = (a < b);     // true
bool isEqual = (a == b);       // false
bool isNotEqual = (a != b);    // true
bool isGreaterOrEqual = (a >= b); // false
bool isLessOrEqual = (a <= b);   // true

逻辑运算符

逻辑运算符用于执行逻辑运算，包括逻辑与（&&）、逻辑或（||）和逻辑非（!）。

bool a = true, b = false;

bool logicAnd = (a && b); // false
bool logicOr = (a || b);  // true
bool logicNot = !a;       // false

控制语句

控制语句用于控制程序的执行流程，包括条件语句（if-else）、循环语句（for, while, do-while）和跳转语句（break, continue, return）。

条件语句

条件语句允许程序根据条件选择不同的执行路径。

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

循环语句

循环语句允许代码块重复执行，直到满足特定条件。

for循环

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

while循环

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

do-while循环

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

跳转语句

跳转语句允许程序在特定条件下跳转到代码块的不同位置。

break

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

continue

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

return

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

函数与对象

定义与调用函数

函数是C++程序的基本构建块，它封装了一段代码，可以在程序的任何位置多次调用。函数可以有返回值和参数。

定义函数

函数的基本语法如下：

返回类型 函数名(参数列表) {
    函数体
}

无返回值函数

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

有返回值函数

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

调用函数

函数可以像调用其他变量一样被调用。调用函数时，需要提供必要的参数。

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

类与对象

类是C++面向对象编程的核心概念，它定义了对象的结构和行为。对象是类的实例，用于存储特定的数据和执行特定的操作。

定义类

类的基本语法如下：

class 类名 {
    private:
        成员变量;  // 私有成员变量
    public:
        成员函数;  // 公有成员函数
};

成员变量

class Person {
private:
    std::string name;
    int age;
};

成员函数

class Person {
private:
    std::string name;
    int age;
public:
    void setName(std::string n) {
        name = n;
    }
    void setAge(int a) {
        age = a;
    }
    std::string getName() {
        return name;
    }
    int getAge() {
        return age;
    }
};

创建对象

对象是类的实例，可以通过类名创建。

int main() {
    Person p;
    p.setName("Alice");
    p.setAge(25);
    std::cout << "Name: " << p.getName() << ", Age: " << p.getAge() << std::endl;
    return 0;
}

成员函数与数据成员

成员函数可以访问类的私有成员变量，提供封装和数据保护。成员变量用于存储对象的状态。

成员函数访问成员变量

成员函数可以直接访问类的私有成员变量，而外部函数不能。

class Person {
private:
    std::string name;
    int age;
public:
    void setName(std::string n) {
        name = n;
    }
    void setAge(int a) {
        age = a;
    }
    std::string getName() {
        return name;
    }
    int getAge() {
        return age;
    }
};

数据成员的封装

通过成员函数封装数据成员，可以更好地控制对象的状态和行为。

int main() {
    Person p;
    p.setName("Alice");
    p.setAge(25);
    std::cout << "Name: " << p.getName() << ", Age: " << p.getAge() << std::endl;
    return 0;
}

C++11新特性详解

智能指针

智能指针是C++11引入的重要新特性，它们可以帮助开发者更安全地管理内存。

`std::unique_ptr`

std::unique_ptr是一个独占所有权的智能指针，只允许一个智能指针实例拥有对象。

#include <memory>
#include <iostream>

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

`std::shared_ptr`

std::shared_ptr允许多个智能指针共享同一个对象的所有权。

#include <memory>
#include <iostream>

int main() {
    std::shared_ptr<int> ptr1(new int(10));
    std::shared_ptr<int> ptr2 = ptr1;

    *ptr1 = 20;
    std::cout << *ptr1 << ", " << *ptr2 << std::endl;

    return 0;
}

异步与并发

C++11引入了线程库，使得编写并发程序变得更加容易。

线程创建与启动

可以使用std::thread类创建和启动线程。

#include <iostream>
#include <thread>

void threadFunction() {
    std::cout << "Thread function executed." << std::endl;
}

int main() {
    std::thread t(threadFunction);
    t.join();
    return 0;
}

线程同步

线程同步是并发编程中重要的部分，可以使用互斥锁（std::mutex）来实现。

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

std::mutex mtx;

void threadFunction(int id) {
    std::lock_guard<std::mutex> lock(mtx);
    std::cout << "Thread " << id << " is running." << std::endl;
}

int main() {
    std::thread t1(threadFunction, 1);
    std::thread t2(threadFunction, 2);
    t1.join();
    t2.join();
    return 0;
}

新的语法糖

C++11引入了许多新的语法糖，使代码更简洁易读。

Lambda表达式

Lambda表达式是匿名函数的一种形式，可以内联定义和使用。

#include <iostream>

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

范围for循环

范围for循环简化了数组和容器的遍历。

#include <vector>
#include <iostream>

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

初始化器列表

初始化器列表允许使用统一的初始化语法初始化对象。

#include <iostream>
#include <vector>

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

实践与项目案例

小项目实践

通过实践项目可以加深对C++11新特性的理解和应用。

实践项目1：计算器

使用C++11的特性实现一个简单的计算器，能够进行加、减、乘、除运算。

#include <iostream>
#include <string>

using namespace std;

int calculate(const string& op, int a, int b) {
    if (op == "+") {
        return a + b;
    } else if (op == "-") {
        return a - b;
    } else if (op == "*") {
        return a * b;
    } else if (op == "/") {
        return a / b;
    } else {
        return 0;
    }
}

int main() {
    int a, b;
    string op;
    cout << "Enter two numbers and an operator (+, -, *, /): ";
    cin >> a >> b >> op;
    int result = calculate(op, a, b);
    cout << "Result: " << result << endl;
    return 0;
}

实践项目2：多线程任务

使用线程库实现一个多线程任务，模拟并行计算。

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

std::mutex mtx;

void threadFunction(int id) {
    std::lock_guard<std::mutex> lock(mtx);
    std::cout << "Thread " << id << " is running." << std::endl;
}

int main() {
    std::thread t1(threadFunction, 1);
    std::thread t2(threadFunction, 2);
    t1.join();
    t2.join();
    return 0;
}

常见问题与解决方案

在学习和实践中，经常会遇到一些常见问题，以下是一些常见问题及其解决方案。

问题1：类型推断

C++11引入了auto关键字用于类型推断，但需要注意的是，auto关键字不能用于结构化绑定。

auto a = 10; // 正确
auto& b = 10; // 错误，不能用于非引用类型

问题2：内存泄漏

使用智能指针可以避免内存泄漏问题。

#include <memory>
#include <iostream>

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

未使用智能指针时会发生内存泄漏：

#include <iostream>

int main() {
    int* ptr = new int(10); // 未使用智能指针
    *ptr = 20;
    std::cout << *ptr << std::endl;
    // 忘记删除指针，导致内存泄漏
    return 0;
}

问题3：多线程数据竞争

使用互斥锁可以避免多线程数据竞争问题。

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

std::mutex mtx;

void threadFunction(int id) {
    std::lock_guard<std::mutex> lock(mtx);
    std::cout << "Thread " << id << " is running." << std::endl;
}

int main() {
    std::thread t1(threadFunction, 1);
    std::thread t2(threadFunction, 2);
    t1.join();
    t2.join();
    return 0;
}

未使用互斥锁时会发生数据竞争：

#include <iostream>
#include <thread>

int sharedVar = 0;

void increment() {
    for (int i = 0; i < 10000; ++i) {
        ++sharedVar;
    }
}

int main() {
    std::thread t1(increment);
    std::thread t2(increment);

    t1.join();
    t2.join();

    std::cout << "Shared variable: " << sharedVar << std::endl;
    return 0;
}

通过学习和实践C++11的新特性，你可以编写出更简洁、更高效、更安全的程序。希望这篇教程能够帮助你掌握C++11的基础知识和实践技巧。

点击查看更多内容

为 TA 点赞

若觉得本文不错，就分享一下吧！

评论

评论

共同学习，写下你的评论

评论加载中...

展开查看更多评论

作者其他优质文章

正在加载中

慕斯王

手记
篇

粉丝

110

获赞与收藏

512

关注作者，订阅最新文章

阅读免费教程

Android Studio 编辑器教程

40个小节 11846 244

后端通用面试教程

41个小节 30583 343

网络编程入门教程

20个小节 12561 237

推荐

评论

收藏

共同学习，写下你的评论



感谢您的支持，我会继续努力的～

扫码打赏，你说多少就多少

赞赏金额会直接到老师账户

支付方式

打开微信扫一扫，即可进行扫码打赏哦

今天注册有机会得

100积分直接送

付费专栏免费学

大额优惠券免费领

立即参与放弃机会

点击
抽奖

慕课手记新用户专享福利

恭喜你，你的运气太好了，居然抽中了 100个积分！

恭喜你，抽中了价值元的专栏！

太棒了，直接落到你账户里！

积分商城里的罗技鼠标、机械键盘、
Kindle 阅读器、小米平衡车
Apple iPad （10.2英寸）、大额优惠券
在等着你去兑换了噢

作者：

免费赠送

兑换码：1111222211 复制

优惠券可用于购买实战课、体系课
无门槛使用

先去看看，有什么好东西马上兑换我爱学习，选课去


热搜

最近搜索清空

C++11教程：新手入门与基础实践

C++11新特性概览

C++11与旧版本对比

安装编译器

GCC（GNU Compiler Collection）

Clang

Visual Studio

配置集成开发环境（IDE）

Visual Studio Code

CLion

Visual Studio

变量与数据类型

基本类型

复杂类型

基本运算符

算术运算符

位运算符

关系运算符

逻辑运算符

控制语句

条件语句

循环语句

跳转语句

定义与调用函数

定义函数

调用函数

类与对象

定义类

创建对象

成员函数与数据成员

成员函数访问成员变量

数据成员的封装

智能指针

std::unique_ptr

std::shared_ptr

异步与并发

线程创建与启动

线程同步

新的语法糖

Lambda表达式

范围for循环

初始化器列表

小项目实践

实践项目1：计算器

实践项目2：多线程任务

常见问题与解决方案

问题1：类型推断

问题2：内存泄漏

问题3：多线程数据竞争

阅读免费教程

`std::unique_ptr`

`std::shared_ptr`