【C++ 面试 - 新特性】每日 3 题（四）

✍个人博客：Pandaconda-CSDN博客
📣专栏地址：http://t.csdnimg.cn/fYaBd
📚专栏简介：在这个专栏中，我将会分享 C++ 面试中常见的面试题给大家~
❤️如果有收获的话，欢迎点赞👍收藏📁，您的支持就是我创作的最大动力💪

10. 独占指针，怎么实现不可复制，能否作为返回值，为什么？

独占指针（Exclusive Ownership Pointer）指的是拥有资源的指针，它在 C++ 中通常使用智能指针来实现。要实现一个不可复制的独占指针，可以通过禁用复制构造函数和赋值运算符来实现。
以下是实现一个不可复制独占指针的一个简单示例：

#include <iostream>
class ExclusivePtr {
public:
    ExclusivePtr(int* ptr) : m_ptr(ptr) {}
    ~ExclusivePtr() { delete m_ptr; }
    // 禁用复制构造函数
    ExclusivePtr(const ExclusivePtr&) = delete;
    // 禁用赋值运算符
    ExclusivePtr& operator=(const ExclusivePtr&) = delete;
    int* get() const { return m_ptr; }
private:
    int* m_ptr;
};
int main() {
    int* rawPtr = new int(42);
    ExclusivePtr ptr(rawPtr);
    // 编译报错：‘ExclusivePtr::ExclusivePtr(const ExclusivePtr&)’ is private within this context
    ExclusivePtr ptr2 = ptr; // 禁止复制构造
    // 编译报错：‘ExclusivePtr& ExclusivePtr::operator=(const ExclusivePtr&)’ is private within this context
    ExclusivePtr ptr3;
    ptr3 = ptr; // 禁止赋值运算
    return 0;
}

上述代码中，通过将复制构造函数和赋值运算符设为私有，并且使用 = delete 关键字阻止其使用，从而禁止了对独占指针对象的复制和赋值操作。
关于将独占指针作为返回值，理论上是可以的。因为这样做可以保证对资源的独占，防止资源泄露或者多个指针指向同一个资源。不过需要注意的是，如果用独占指针作为返回值，就无法再次复制或赋值给其他独占指针，因为复制和赋值操作被禁止了。如果需要将资源转移给另一个指针，可以使用移动构造函数和移动赋值运算符。
总之，通过禁用复制构造函数和赋值运算符，可以实现一个不可复制的独占指针，并且可以将它作为返回值使用，但需要注意不能复制或赋值给其他独占指针对象。

11. 自动类型推导

（1）auto
C++11 新标准引入了 auto 类型说明符，用它就能让编译器替我们去分析表达式所属的类型。和原来那些只对应某种特定的类型说明符 (例如 int) 不同，auto 让编译器通过初始值来进行类型推演。从而获得定义变量的类型，所以说 auto 定义的变量必须有初始值。
举个例子：

//普通；类型
int a = 1, b = 3;
auto c = a + b;// c为int型

//const类型
const int i = 5;
auto j = i; // 变量i是顶层const, 会被忽略, 所以j的类型是int
auto k = &i; // 变量i是一个常量, 对常量取地址是一种底层const, 所以k的类型是const int*
const auto l = i; //如果希望推断出的类型是顶层const的, 那么就需要在auto前面加上const

//引用和指针类型
int x = 2;
int& y = x;
auto z = y; //z是int型不是int& 型
auto& p1 = y; //p1是int&型
auto p2 = &x; //p2是指针类型int*

（2）decltype
有的时候我们还会遇到这种情况，我们希望从表达式中推断出要定义变量的类型，但却不想用表达式的值去初始化变量。还有可能是函数的返回类型为某表达式的值类型。在这些时候 auto 显得就无力了，所以 C++11 又引入了第二种类型说明符 decltype，它的作用是选择并返回操作数的数据类型。在此过程中，编译器只是分析表达式并得到它的类型，却不进行实际的计算表达式的值。

int func() {return 0};

//普通类型
decltype(func()) sum = 5; // sum的类型是函数func()的返回值的类型int, 但是这时不会实际调用函数func()
int a = 0;
decltype(a) b = 4; // a的类型是int, 所以b的类型也是int

//不论是顶层const还是底层const, decltype都会保留   
const int c = 3;
decltype(c) d = c; // d的类型和c是一样的, 都是顶层const
int e = 4;
const int* f = &e; // f是底层const
decltype(f) g = f; // g也是底层const

//引用与指针类型
//1. 如果表达式是引用类型, 那么decltype的类型也是引用
const int i = 3, &j = i;
decltype(j) k = 5; // k的类型是 const int&

//2. 如果表达式是引用类型, 但是想要得到这个引用所指向的类型, 需要修改表达式:
int i = 3, &r = i;
decltype(r + 0) t = 5; // 此时是int类型

//3. 对指针的解引用操作返回的是引用类型
int i = 3, j = 6, *p = &i;
decltype(*p) c = j; // c是int&类型, c和j绑定在一起

//4. 如果一个表达式的类型不是引用, 但是我们需要推断出引用, 那么可以加上一对括号, 就变成了引用类型了
int i = 3;
decltype((i)) j = i; // 此时j的类型是int&类型, j和i绑定在了一起

（3）decltype(auto)
decltype(auto) 是 C++14 新增的类型指示符，可以用来声明变量以及指示函数返回类型。在使用时，会将 “=” 号左边的表达式替换掉 auto，再根据 decltype 的语法规则来确定类型。举个例子：

int e = 4;
const int* f = &e; // f是底层const
decltype(auto) j = f;//j的类型是const int* 并且指向的是e

12. 可变参数模板

C++11 之前，类模版和函数模版中只能含固定数量的模版参数。
C++11 的新特性可变参数模板能够让您创建可以接受可变参数的函数模板和类模板。

#include <iostream>
using namespace std;
//函数模板的参数个数为0到多个参数，每个参数的类型可以各不相同
template<class...T>
void funcName(T...args) {//args一包形参，T一包类型
    cout << sizeof...(args) << endl;//sizeof...固定语法格式计算获取到模板参数的个数
    cout << sizeof...(T) << endl;//注意sizeof...只能计算...的可变参
}
int main() {
    funcName(100, 200, 300,400,600);
    return 0;
}

参数包展开：
递归函数

//递归
#include <iostream>
using namespace std;
void funcName1() {
    cout << "递归终止函数" << endl;
}
template<class T, class ...U>
void funcName1(T frist, U...others) {
    cout << "收到的参数值:" << frist << endl;
    funcName1(others...);//注意这里传进来的是一包形参不能省略... 
}
int main() {
    funcName1(1, 2, 3, 4, 5, 6);
    return 0;
}

使用 if constexpr

//if constexpr
#include <iostream>
using namespace std;
//if constexpr...()//constexpr代表的是常量的意思或者是编译时求值
//c++17中新增一个语句叫做编译期间if语句（ constexpr if）
template<class T, class...U>
void funcName2(T frist, U...args) {
    cout << "收到参数：" << frist << endl;
    if constexpr (sizeof...(args) > 0) {
        //constexpr必须有否则无法编译成功，圆括号里面是常量表达式
        funcName2(args...);
    }
}
int main() {
    funcName2(1,2, 3, 4, 5, 6);
    return 0;
}