首页手记 C++11学习：从入门到初步掌握

C++11学习：从入门到初步掌握

标签：

C++

本文介绍了C++11的新特性和环境搭建方法，帮助读者快速入门C++11学习。文章详细讲解了C++11的语法改进、开发环境配置以及基本程序示例，旨在让读者掌握C++11的核心概念和开发技巧。C++11学习涵盖了从变量类型到函数定义，从条件语句到面向对象编程，内容丰富全面。

C++11简介与环境搭建

C++11简介

C++11是C++编程语言的一个重要版本，于2011年正式发布。相比之前的C++版本（如C++98），C++11引入了大量的新特性和改进，使编程更加简单、高效，并且更符合现代编程的需求。以下是一些主要的新特性：

智能指针：std::unique_ptr 和 std::shared_ptr 提供了更安全的内存管理方式。
自动类型推断：在声明变量时，可以使用 auto 关键字，编译器会自动推断变量的类型。
类型推导的 decltype：decltype 用于推导表达式的类型，可用于模板元编程。
范围for循环：简化了数组和容器的遍历。
lambda表达式：提供了一种简洁的方式来定义匿名函数。
右值引用：引入了 std::move，允许对象在不再需要时被移动，而不是拷贝。
初始化列表：提供了初始化变量的新方式。
强枚举：增强了枚举类型的安全性和类型检查。

这些新特性不仅改进了语言的语法和表达能力，还提高了代码的可读性和可维护性。

开发环境搭建

要开始使用C++11，你需要一个支持C++11的开发环境。以下是搭建环境的步骤：

安装C++编译器：
- Ubuntu:
```
sudo apt-get update
sudo apt-get install build-essential
```
- macOS:
```
brew install gcc
```
- Windows:
  使用 Visual Studio 或 MinGW。
配置编译器：
- 在命令行中，使用 g++ 编译器时，可以通过添加 -std=c++11 或 -std=c++1z（对于C++14和C++17）来指定使用C++11标准。
- 示例：
```
g++ -std=c++11 hello.cpp -o hello
```
集成开发环境（IDE）：
- Visual Studio Code: 安装C++插件。
- CLion: 安装后自动配置编译器。
- Visual Studio: 选择C++项目模板。

首个C++11程序

编写一个简单的“Hello, World!”程序来展示C++11的基本结构。

#include <iostream>

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

编译并运行这个程序：

g++ -std=c++11 hello.cpp -o hello
./hello

输出：

Hello, World!

基础语法

变量与数据类型

变量是用来存储数据的容器，C++11支持多种数据类型。以下是一些基本的数据类型：

整型：
- int: 有符号整数。
- unsigned int: 无符号整数。
- long: 长整数。
- short: 短整数。
- long long: 长长整数。
浮点型：
- float: 单精度浮点数。
- double: 双精度浮点数。
- long double: 长双精度浮点数。
字符型：
- char: 字符。
- wchar_t: 宽字符。
- char16_t: 16位字符。
- char32_t: 32位字符。
布尔型：
- bool: 布尔值，true 或 false。

C++11引入了 auto 关键字，允许编译器自动推断变量的类型。例如：

auto x = 10;          // x 的类型为 int
auto y = 3.14f;       // y 的类型为 float
auto z = 'A';         // z 的类型为 char
auto b = true;        // b 的类型为 bool

使用 auto 关键字可以简化代码，特别是处理复杂类型时。

基本运算符

C++11支持多种运算符，包括算术运算符、关系运算符、逻辑运算符等。以下是基本的运算符及其用法：

算术运算符：
- +：加法
- -：减法
- *：乘法
- /：除法
- %：取模

int a = 10, b = 5;
int sum = a + b;
int diff = a - b;
int product = a * b;
int quotient = a / b;
int remainder = a % b;

关系运算符：
- ==：等于
- !=：不等于
- >：大于
- <：小于
- >=：大于等于
- <=：小于等于

if (a > b) {
    std::cout << "a is greater than b" << std::endl;
} else {
    std::cout << "b is greater than or equal to a" << std::endl;
}

逻辑运算符：
- &&：逻辑与
- ||：逻辑或
- !：逻辑非

bool x = true, y = false;
bool result = (x && y); // result 为 false
result = (x || y);      // result 为 true
result = !x;            // result 为 false

通过这些运算符，可以对变量进行基本的数学操作和逻辑判断。

条件语句与循环

条件语句和循环是控制程序流程的重要工具，C++11提供了多种控制结构来实现这些功能。

if 语句

if 语句根据条件执行代码块。条件表达式的结果必须是布尔值。

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

switch 语句

switch 语句根据变量的值执行不同的代码块。

int num = 2;
switch (num) {
    case 1:
        std::cout << "num is 1" << std::endl;
        break;
    case 2:
        std::cout << "num is 2" << std::endl;
        break;
    default:
        std::cout << "num is not 1 or 2" << std::endl;
}

for 循环

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

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

while 循环

while 循环在条件为真时重复执行一段代码。

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

do-while 循环

do-while 循环在循环体执行后检查条件，如果条件为真，则继续执行循环体。

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

通过这些控制结构，可以灵活地控制程序的流程。

函数与数组

函数定义与调用

函数是一段可重用的代码块，用于执行特定任务并返回结果。C++11中函数的定义和调用如下：

函数定义

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

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

函数调用

函数调用通过函数名并传递参数来调用。

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

带默认参数的函数

C++允许函数定义时提供默认参数，调用时可以省略这些参数。

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

int main() {
    int result1 = multiply(3);       // 使用默认参数
    int result2 = multiply(3, 4);    // 指定参数
    std::cout << "Result1: " << result1 << std::endl;
    std::cout << "Result2: " << result2 << std::endl;
    return 0;
}

数组的使用

数组是一种基本的数据结构，用于存储一组相同类型的元素。C++支持静态数组和动态数组。

静态数组

静态数组在声明时指定大小，大小固定不变。

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

动态数组

动态数组使用 new 关键字在运行时分配内存。

int* arr = new int[5];
for (int i = 0; i < 5; i++) {
    arr[i] = i + 1;
}
for (int i = 0; i < 5; i++) {
    std::cout << "arr[" << i << "]: " << arr[i] << std::endl;
}
delete[] arr;

字符串操作

C++11 引入了 std::string 类，用于处理字符串数据。std::string 提供了丰富的操作和方法。

字符串基础

std::string str = "Hello, World!";
std::cout << "Length: " << str.length() << std::endl;
std::cout << "Substring: " << str.substr(7, 5) << std::endl;
std::cout << "Find 'World': " << str.find("World") << std::endl;

字符串拼接

std::string str1 = "Hello, ";
std::string str2 = "World!";
std::string result = str1 + str2;
std::cout << "Result: " << result << std::endl;

字符串输入输出

std::string input;
std::cout << "Enter a string: ";
std::getline(std::cin, input);
std::cout << "You entered: " << input << std::endl;

通过这些基本操作，可以实现字符串的输入、输出和处理。

指针与引用

指针基础

指针是一个变量，它存储另一个变量的地址。指针的使用可以使程序更灵活和高效。

定义指针

int num = 10;
int* ptr = &num;
std::cout << "Value: " << num << std::endl;
std::cout << "Address: " << ptr << std::endl;
std::cout << "Value (via pointer): " << *ptr << std::endl;

指针运算

指针支持诸如指针递增（++）、指针减小（--）、指针加法（+）、指针减法（-）等运算。

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

引用的应用

引用是变量的别名，引用的值和被引用的变量值相同。C++11中引用的应用广泛。

定义引用

int a = 10;
int& ref = a;
ref = 20;
std::cout << "a: " << a << std::endl;  // 输出 20

引用传递

在函数中使用引用传递参数可以避免复制操作，提高性能。

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

int main() {
    int num = 10;
    increment(num);
    std::cout << "num: " << num << std::endl;  // 输出 11
    return 0;
}

动态内存管理

C++11提供了 std::unique_ptr 和 std::shared_ptr 来管理动态分配的内存。

unique_ptr

std::unique_ptr 是一个独占所有权的智能指针，不允许复制，只能移动。

#include <memory>

int main() {
    std::unique_ptr<int> ptr1(new int(10));
    std::cout << "ptr1: " << *ptr1 << std::endl;

    std::unique_ptr<int> ptr2(std::move(ptr1));
    std::cout << "ptr2: " << *ptr2 << std::endl;

    // std::unique_ptr<int> ptr3(ptr1);  // 错误，不允许复制
    return 0;
}

shared_ptr

std::shared_ptr 允许多个共享同一份内存，并通过引用计数来管理内存。

#include <memory>

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

    *ptr1 = 20;
    std::cout << "ptr1: " << *ptr1 << std::endl;  // 输出 20
    std::cout << "ptr2: " << *ptr2 << std::endl;  // 输出 20
    return 0;
}

通过这些智能指针，可以简化内存管理，避免内存泄漏。

面向对象编程基础

类与对象

类是对象的蓝图，对象是类的实例。C++11中类的定义和对象的创建如下：

定义类

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

    void display() {
        std::cout << "Name: " << name << ", Age: " << age << std::endl;
    }
};

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

对象的创建

Person p;
p.name = "Bob";
p.age = 30;
p.display();

构造与析构函数

构造函数是创建对象时自动调用的函数，用于初始化对象。析构函数是对象销毁时自动调用的函数，用于清理资源。

构造函数

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

    Person(std::string n, int a) : name(n), age(a) {}

    void display() {
        std::cout << "Name: " << name << ", Age: " << age << std::endl;
    }
};

int main() {
    Person p("Alice", 25);
    p.display();
    return 0;
}

析构函数

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 display() {
        std::cout << "Name: " << name << ", Age: " << age << std::endl;
    }
};

int main() {
    {
        Person p("Alice", 25);
        p.display();
    }  // p 对象在离开作用域后被销毁
    return 0;
}

继承与多态

继承允许一个类继承另一个类的属性和方法，多态则允许子类覆盖基类的方法。

继承

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

    void display() {
        std::cout << "Name: " << name << ", Age: " << age << std::endl;
    }
};

class Student : public Person {
public:
    int rollNumber;

    Student(std::string n, int a, int r) : Person(n, a), rollNumber(r) {}

    void display() {
        std::cout << "Name: " << name << ", Age: " << age << ", Roll Number: " << rollNumber << std::endl;
    }
};

int main() {
    Student s("Alice", 25, 1);
    s.display();
    return 0;
}

多态

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

    virtual void display() {
        std::cout << "Name: " << name << ", Age: " << age << std::endl;
    }
};

class Student : public Person {
public:
    int rollNumber;

    Student(std::string n, int a, int r) : Person(n, a), rollNumber(r) {}

    void display() {
        std::cout << "Name: " << name << ", Age: " << age << ", Roll Number: " << rollNumber << std::endl;
    }
};

int main() {
    Person* p = new Student("Alice", 25, 1);
    p->display();  // 调用 Student 的 display() 方法
    return 0;
}

通过这些基本概念，可以实现更复杂的面向对象编程。

新特性介绍

auto 关键字

auto 关键字可以帮助编译器自动推断变量的类型，简化代码。

基本用法

auto x = 10;  // x 的类型为 int
auto y = 3.14f;  // y 的类型为 float
auto z = "Hello";  // z 的类型为 const char*
auto b = true;  // b 的类型为 bool

使用 `auto` 与模板

template <typename T>
auto sum(T a, T b) -> decltype(a + b) {
    return a + b;
}

int main() {
    auto result = sum(3, 5);
    std::cout << "Result: " << result << std::endl;

    auto result2 = sum(3.14f, 2.71f);
    std::cout << "Result2: " << result2 << std::endl;
    return 0;
}

lambda 表达式

lambda 表达式是一种匿名函数，可以在代码中直接定义和使用。

基本用法

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

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

捕获变量

int x = 10;
auto lambda = [x]() {
    return x * 2;
};

int result = lambda();
std::cout << "Result: " << result << std::endl;

range-based for 循环

range-based for 循环可以简化遍历数组和容器的操作。

基本用法

int arr[] = {1, 2, 3, 4, 5};
for (auto& x : arr) {
    std::cout << x << std::endl;
}

使用 vector

#include <vector>

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

通过这些新特性，可以写出更简洁和高效的代码。

通过以上内容，你已经了解了C++11的基本概念和新特性，可以开始编写更复杂的应用程序了。如果有疑问，可以参考更多的资料或在慕课网学习更深入的知识。

点击查看更多内容

为 TA 点赞

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

评论

评论

共同学习，写下你的评论

评论加载中...

展开查看更多评论

作者其他优质文章

正在加载中

紫衣仙女

手记
篇

粉丝

71

获赞与收藏

334

关注作者，订阅最新文章

阅读免费教程

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程序

变量与数据类型

基本运算符

条件语句与循环

if 语句

switch 语句

for 循环

while 循环

do-while 循环

函数定义与调用

函数定义

函数调用

带默认参数的函数

数组的使用

静态数组

动态数组

字符串操作

字符串基础

字符串拼接

字符串输入输出

指针基础

定义指针

指针运算

引用的应用

定义引用

引用传递

动态内存管理

unique_ptr

shared_ptr

类与对象

定义类

对象的创建

构造与析构函数

构造函数

析构函数

继承与多态

继承

多态

auto 关键字

基本用法

使用 auto 与模板

lambda 表达式

基本用法

捕获变量

range-based for 循环

基本用法

使用 vector

阅读免费教程

使用 `auto` 与模板