关于c++:面试高频问题之C11新特性

背景

C++11 是 C ++ 语言的一个重大更新，引入了许多新个性，包含主动类型推导、lambda 表达式、右值援用、智能指针等等。这些新个性使得 C ++ 更加现代化、高效、易用。也是面试容很容易被问到一个问题，上面我将简要介绍一些 C ++11 的新个性：

主动类型推导

C++11 引入了 auto 关键字，能够让编译器主动推导变量的类型。这样能够缩小代码中的反复代码，进步代码的可读性和可维护性。例如：

auto i = 42; // 推导为 int 类型
auto d = 3.14; // 推导为 double 类型
auto s = "hello"; // 推导为 const char* 类型 

lambda 表达式

C++11 引入了 lambda 表达式，能够不便地定义匿名函数。这样能够缩小代码中的反复代码，进步代码的可读性和可维护性。例如：

auto f = [](int x, int y) {return x + y;};
int z = f(1, 2); // z 的值为 3 

右值援用

C++11 引入了右值援用，能够不便地实现挪动语义和完满转发。这样能够进步代码的性能和效率。例如：

class MyString {
public:
    MyString() : data_(nullptr), size_(0) {}
    MyString(const char* str) : data_(new char[strlen(str) + 1]), size_(strlen(str)) {strcpy(data_, str);
    }
    MyString(MyString&& other) : data_(other.data_), size_(other.size_) {
        other.data_ = nullptr;
        other.size_ = 0;
    }
    ~MyString() {delete[] data_;
    }
private:
    char* data_;
    size_t size_;
};

更多对于右值援用的内容，感兴趣的小伙伴能够翻看我之前的帖子，有专门的介绍。

智能指针

C++11 引入了智能指针，能够不便地治理动态分配的内存，防止内存透露和悬空指针的问题。C++11 中有两种智能指针：std::unique_ptr 和 std::shared_ptr。

std::unique_ptr 是一种独占式智能指针，它领有对动态分配的对象的惟一所有权。当 std::unique_ptr 被销毁时，它所领有的对象也会被销毁。例如：

std::unique_ptr<int> p(new int(42));
std::cout << *p << std::endl; // 输入 42

std::shared_ptr 是一种共享式智能指针，它能够被多个指针共享拥有权。当最初一个 std::shared_ptr 被销毁时，它所领有的对象也会被销毁。例如：

std::shared_ptr<int> p1(new int(42));
std::shared_ptr<int> p2 = p1;
std::cout << *p1 << " " << *p2 << std::endl; // 输入 42 42

C++11 的智能指针使得动态内存治理更加不便和平安。

range-based for 循环

C++11 引入了 range-based for 循环，能够不便地遍历容器中的元素。这样能够缩小代码中的反复代码，进步代码的可读性和可维护性。例如：

std::vector<int> v = {1, 2, 3, 4, 5};
for (auto x : v) {std::cout << x << std::endl;}

nullptr

C++11 引入了 nullptr 关键字，能够代替 NULL 宏定义。这样能够防止一些潜在的谬误。例如：

void f(int* p) {}
f(nullptr); // 能够编译通过 

constexpr

C++11 引入了 constexpr 关键字，能够在编译期间计算表达式的值。这样能够进步代码的性能和效率。例如：

constexpr int factorial(int n) {return n == 0 ? 1 : n * factorial(n - 1);
}
int x = factorial(5); // x 的值为 120

更多对于 constexpr 的内容，感兴趣的小伙伴能够翻看我之前的帖子，有专门的介绍。

static_assert

C++11 引入了 static_assert 关键字，能够在编译期间查看表达式的值是否为真。这样能够防止一些潜在的谬误。例如：

static_assert(sizeof(int) == 4, "int must be 4 bytes"); // 如果 sizeof(int) 不等于 4，编译会失败 

变长参数模板

C++11 引入了变长参数模板，能够不便地解决可变数量的参数。这样能够进步代码的灵活性和可维护性。例如：

template<typename... Args>
void f(Args... args) {std::cout << sizeof...(args) << std::endl; // 打印参数的数量
}
f(1, 2, 3); // 打印 3
f("hello", 3.14); // 打印 2 

线程反对库

C++11 引入了线程反对库，能够不便地创立和治理线程。这样能够进步代码的并发性和可维护性。例如：

#include <iostream>
#include <thread>
void f() {std::cout << "hello, world" << std::endl;}
int main() {std::thread t(f); // 创立一个新线程
    t.join(); // 期待线程完结
    return 0;
}

结尾

以上是 C ++11 的一些新个性，它们使得 C ++ 更加现代化、高效、易用。