C++11语法资料入门教程

本文主要是介绍C++11语法资料入门教程，对大家解决编程问题具有一定的参考价值，需要的程序猿们随着小编来一起学习吧！

概述

本文详细介绍了C++11语法资料，包括新特性和改进，如语法简化、类型推断、内存管理和循环结构的增强。文章还涵盖了安装与配置C++11开发环境的方法，以及C++11中的变量类型、控制结构、函数与lambda表达式、类与对象及实用特性。通过示例代码帮助读者更好地理解和应用这些新特性。

C++11基础知识简介

C++11简介

C++11是C++语言的一个重要版本，它引入了许多新特性和改进，旨在简化编程并提高代码的可读性和可维护性。C++11标准于2011年正式发布，是自C++98以来的第一个重大更新。它提供了新的语法特性、类型推断、更好地支持多线程编程，以及更强大的库支持。

C++11与早期版本的区别

C++11与早期版本相比，主要区别在于以下几个方面：

语法简化：引入了auto关键字，简化变量声明。
更友好的类型推断：decltype关键字使得类型推断更加方便。
改进的内存管理：nullptr关键字代替了传统的NULL。
更强大的循环结构：for循环和range-based for循环的改进。
函数模板和变量模板：简化模板的使用。
智能指针：提高了对象生命周期管理的灵活性和安全性。
lambda表达式：提供了内联匿名函数的功能。
更强大的库支持：增强了STL容器和算法的使用。

安装与配置C++11开发环境

为了编写和测试C++11代码，需要安装并配置支持C++11的编译器，如GCC、Clang或MSVC。下列步骤以Linux环境下的GCC为例进行说明。

安装GCC：

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

检查GCC版本：
```
g++ --version
```
编译C++11代码：
使用-std=c++11或-std=c++1z来启用C++11标准。例如：
```
g++ -std=c++11 main.cpp -o main
```
这样编译器会使用C++11标准来编译main.cpp文件。

C++11变量与数据类型

基本数据类型介绍

C++11继续支持C++98中的基本数据类型，包括整型、浮点型、字符型等。此外，C++11引入了新的类型别名std::int_fastN_t和std::int_leastN_t等，以适应不同系统架构下的类型要求。

#include <iostream>
#include <cstdint>

int main() {
    int i = 10;
    float f = 10.5f;
    char c = 'A';
    std::int8_t i8 = -128;  // 8位有符号整型
    std::uint16_t u16 = 65535;  // 16位无符号整型

    std::cout << "i: " << i << ", f: " << f << ", c: " << c << std::endl;
    std::cout << "i8: " << i8 << ", u16: " << u16 << std::endl;

    return 0;
}

auto关键字的使用

auto关键字可以用于推断变量类型，简化代码的书写。当编译器能够从赋值表达式中推断出变量的类型时，auto关键字可以帮助自动推断。

#include <iostream>

int main() {
    auto i = 10;  // 推断为int
    auto f = 10.5f;  // 推断为float
    auto c = 'A';  // 推断为char
    auto d = 10.5;  // 推断为double
    auto v = std::vector<int>{1, 2, 3};  // 推断为std::vector<int>

    std::cout << "i: " << i << ", f: " << f << ", c: " << c << std::endl;
    std::cout << "d: " << d << ", v: ";
    for (int num : v) {
        std::cout << num << " ";
    }
    std::cout << std::endl;

    return 0;
}

decltype关键字的使用

decltype关键字用于推断变量或表达式的类型。它可以用于编译时类型检查和模板元编程。

#include <iostream>

int main() {
    int i = 10;
    decltype(i) j = 20;  // j的类型也推断为int

    std::cout << "i: " << i << ", j: " << j << std::endl;

    return 0;
}

nullptr关键字的使用

nullptr是一个新的关键字，用于表示空指针。它比传统的NULL更清晰，且不会与整型0混淆。

#include <iostream>

int main() {
    int* p = nullptr;

    if (p == nullptr) {
        std::cout << "p is nullptr" << std::endl;
    } else {
        std::cout << "p is not nullptr" << std::endl;
    }

    return 0;
}

C++11控制结构

for循环的改进

C++11增强了for循环，引入了范围for循环和for循环的初始化部分。初始化部分可以在循环初始时进行初始化变量。

#include <iostream>
#include <vector>

int main() {
    std::vector<int> vec = {1, 2, 3, 4};
    for (int i = 0; i < vec.size(); ++i) {
        std::cout << "vec[" << i << "]: " << vec[i] << std::endl;
    }

    return 0;
}

range-based for循环

范围for循环使得遍历容器更加简洁和直观。

#include <iostream>
#include <vector>

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

    return 0;
}

switch语句的改进

C++11允许在switch语句中使用case标签的范围。

#include <iostream>

int main() {
    int n = 2;
    switch (n) {
        case 0:
            std::cout << "n is 0" << std::endl;
            break;
        case 1:
            std::cout << "n is 1" << std::endl;
            break;
        case 2 ... 4:  // 范围case
            std::cout << "n is between 2 and 4" << std::endl;
            break;
        default:
            std::cout << "n is outside the range" << std::endl;
            break;
    }

    return 0;
}

goto语句的使用

尽管goto语句在现代编程中较少使用，但在某些场景下，它仍然可以帮助简化代码。

#include <iostream>

int main() {
    int n = 2;
    switch (n) {
        case 0:
            std::cout << "n is 0" << std::endl;
            break;
        case 1:
            std::cout << "n is 1" << std::endl;
            break;
        case 2 ... 4:  // 范围case
            std::cout << "n is between 2 and 4" << std::endl;
            break;
        default:
            goto end;
            break;
    }

end:
    std::cout << "End of switch statement" << std::endl;

    return 0;
}

C++11函数与lambda表达式

函数模板

函数模板允许编写可以处理不同类型参数的通用函数。

#include <iostream>

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

int main() {
    int i = sum(10, 20);
    float f = sum(10.5f, 20.5f);

    std::cout << "i: " << i << ", f: " << f << std::endl;

    return 0;
}

变量模板

变量模板允许定义通用的静态变量。

#include <iostream>

template <typename T>
constexpr T pi = T(3.141592);

int main() {
    std::cout << "pi<int>: " << pi<int> << std::endl;
    std::cout << "pi<float>: " << pi<float> << std::endl;

    return 0;
}

函数返回值优化

C++11允许编译器优化返回值的临时对象，以提高性能。

#include <iostream>

class MyClass {
public:
    MyClass() {}
    MyClass(MyClass&& other) {
        std::cout << "Move constructor called" << std::endl;
    }
    MyClass(const MyClass& other) {
        std::cout << "Copy constructor called" << std::endl;
    }
    MyClass& operator=(const MyClass& other) {
        std::cout << "Copy assignment operator called" << std::endl;
        return *this;
    }
    MyClass& operator=(MyClass&& other) {
        std::cout << "Move assignment operator called" << std::endl;
        return *this;
    }
    ~MyClass() {
        std::cout << "Destructor called" << std::endl;
    }
};

MyClass createMyClass() {
    MyClass obj;
    return obj;  // 返回值优化
}

int main() {
    MyClass obj = createMyClass();
    return 0;
}

lambda表达式的使用

lambda表达式允许定义内联匿名函数。

#include <iostream>
#include <vector>

int main() {
    std::vector<int> vec = {1, 2, 3, 4};
    auto sum = [](int a, int b) { return a + b; };
    auto func = [](int n) {
        std::cout << "n: " << n << std::endl;
    };

    std::cout << "sum: " << sum(10, 20) << std::endl;

    for (int num : vec) {
        func(num);
    }

    return 0;
}

C++11类与对象

默认成员函数

C++11允许自动合成类的拷贝构造函数、赋值运算符和析构函数。

#include <iostream>

class MyClass {
public:
    MyClass() {}
    MyClass(const MyClass&) = default;  // 自动合成拷贝构造函数
    MyClass& operator=(const MyClass&) = default;  // 自动合成赋值运算符
    ~MyClass() = default;  // 自动合成析构函数
};

int main() {
    MyClass obj1;
    MyClass obj2 = obj1;  // 拷贝构造函数自动调用

    MyClass obj3 = obj2;
    obj3 = obj1;  // 赋值运算符自动调用

    return 0;
}

constexpr关键字的使用

constexpr关键字用于声明常量表达式，允许编译时计算。

#include <iostream>

constexpr int factorial(int n) {
    return n <= 1 ? 1 : n * factorial(n - 1);
}

int main() {
    constexpr int fact5 = factorial(5);
    std::cout << "factorial(5): " << fact5 << std::endl;

    return 0;
}

常量成员函数

常量成员函数可以用于访问类的常量成员，不允许修改实例的状态。

#include <iostream>

class MyClass {
public:
    MyClass(int value) : m_value(value) {}
    int getValue() const {
        return m_value;
    }
private:
    int m_value;
};

int main() {
    MyClass obj(10);
    std::cout << "obj.getValue(): " << obj.getValue() << std::endl;

    return 0;
}

智能指针的使用

智能指针如std::unique_ptr和std::shared_ptr提供了自动内存管理。

#include <iostream>
#include <memory>

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

    std::shared_ptr<int> ptr2(new int(20));  // shared_ptr
    std::cout << "ptr2: " << *ptr2 << std::endl;

    {
        std::unique_ptr<int> ptr3(new int(30));  // unique_ptr
        std::cout << "ptr3: " << *ptr3 << std::endl;
    }  // ptr3 范围结束，自动释放内存

    std::cout << "ptr2 after ptr3: " << *ptr2 << std::endl;

    return 0;
}

C++11实用特性

强制类型转换

C++11中的static_cast、dynamic_cast、const_cast和reinterpret_cast提供了更安全的类型转换。

#include <iostream>

int main() {
    double d = 10.5f;
    int i = static_cast<int>(d);
    std::cout << "i: " << i << std::endl;

    const int ci = 10;
    int* p = const_cast<int*>(&ci);
    *p = 20;
    std::cout << "ci: " << ci << std::endl;

    return 0;
}

通用属性

C++11中的属性允许在类、变量和函数上添加自定义的元数据。

#include <iostream>

struct my_attribute {};

int main() {
    struct [[my_attribute]] MyClass {
        int value;
    };

    MyClass obj;
    std::cout << "obj.value: " << obj.value << std::endl;

    return 0;
}

三重模板模式

三重模板模式是一种模板元编程技术，通过递归模板实例化来实现复杂的类型推导。

#include <iostream>

template<int N>
struct Triple {
    static constexpr int value = N * 3;
};

int main() {
    constexpr int triple5 = Triple<5>::value;
    std::cout << "triple5: " << triple5 << std::endl;

    return 0;
}

类型特征

C++11引入了std::is_same、std::is_integral等类型特征，用于在运行时或编译时推理类型信息。

#include <iostream>
#include <type_traits>

int main() {
    static_assert(std::is_same<int, int>::value, "int is the same as int");
    static_assert(!std::is_same<int, float>::value, "int is not the same as float");

    std::cout << "int is integral: " << std::is_integral<int>::value << std::endl;
    std::cout << "float is integral: " << std::is_integral<float>::value << std::endl;

    return 0;
}

通过上述内容，您可以了解C++11中的主要特性和示例代码，从而更好地掌握和应用C++11的新特性。

这篇关于C++11语法资料入门教程的文章就介绍到这儿，希望我们推荐的文章对大家有所帮助，也希望大家多多支持为之网！

C/C++教程