MST

星途 面试题库

面试题：C++ 常引用在模板函数参数传递的深度剖析

在 C++ 模板函数中，使用常引用作为参数类型时，会涉及到模板类型推导、生命周期管理和函数重载解析等多个复杂的机制。请深入分析在模板函数 `template <typename T> void func(const T& param)` 中，编译器是如何处理参数类型推导和相关的潜在问题的？并且通过具体的代码示例展示如何避免这些问题以及利用这些机制实现高效的泛型编程。
38.9万 热度难度
编程语言C++

知识考点

AI 面试

面试题答案

一键面试

参数类型推导

  1. 基本类型推导
    • 当调用 func 函数时，编译器会根据传入的实参类型推导出模板参数 T 的类型。例如：
    #include <iostream>
template <typename T>
void func(const T& param) {
    std::cout << "T type deduced: ";
    typeid(T).print_name();
    std::cout << std::endl;
}
int main() {
    int num = 10;
    func(num);
    return 0;
}
    • 在上述代码中，传入 int 类型的变量 num，编译器会推导出 T 为 int，param 的类型为 const int&。
  2. 数组类型推导
    • 如果传入数组，数组会退化为指针类型。例如：
    #include <iostream>
template <typename T>
void func(const T& param) {
    std::cout << "T type deduced: ";
    typeid(T).print_name();
    std::cout << std::endl;
}
int main() {
    int arr[5] = {1, 2, 3, 4, 5};
    func(arr);
    return 0;
}
    • 这里编译器会推导出 T 为 int*，param 的类型为 const int*&。
  3. 函数类型推导
    • 函数名可以作为函数指针传递，此时也会进行类型推导。例如：
    #include <iostream>
void testFunc() {}
template <typename T>
void func(const T& param) {
    std::cout << "T type deduced: ";
    typeid(T).print_name();
    std::cout << std::endl;
}
int main() {
    func(testFunc);
    return 0;
}
    • 编译器会推导出 T 为 void(*)()，param 的类型为 const void(*)&。

生命周期管理

  1. 临时对象的生命周期延长
    • 当传入临时对象作为实参时，其生命周期会延长到 func 函数调用结束。例如：
    #include <iostream>
#include <string>
template <typename T>
void func(const T& param) {
    std::cout << param << std::endl;
}
int main() {
    func(std::string("Hello"));
    return 0;
}
    • 这里 std::string("Hello") 是一个临时对象，由于 param 是 const T& 类型，它的生命周期会延长到 func 函数结束，从而保证 param 在函数内可以安全访问。

函数重载解析

  1. 与非模板函数的重载
    • 如果存在与模板函数 func 同名的非模板函数，编译器会优先匹配非模板函数。例如：
    #include <iostream>
void func(const int& param) {
    std::cout << "Non - template func called: " << param << std::endl;
}
template <typename T>
void func(const T& param) {
    std::cout << "Template func called: ";
    typeid(T).print_name();
    std::cout << std::endl;
}
int main() {
    int num = 10;
    func(num);
    return 0;
}
    • 这里会调用非模板函数 func(const int& param)，因为非模板函数是一个更好的匹配。

潜在问题及解决

  1. 类型推导歧义
    • 问题：当有多个模板函数存在，且它们的参数类型推导可能产生歧义时，编译会出错。例如：
    template <typename T>
void func(const T& param) {
    std::cout << "General template" << std::endl;
}
template <typename T>
void func(const T* param) {
    std::cout << "Pointer template" << std::endl;
}
int main() {
    int num = 10;
    func(&num); // 编译错误，类型推导歧义
    return 0;
}
    • 解决：明确指定模板参数或者修改模板函数使其更具特异性。例如：
    template <typename T>
void func(const T& param) {
    std::cout << "General template" << std::endl;
}
template <typename T>
void func(const T* param, int = 0) {
    std::cout << "Pointer template" << std::endl;
}
int main() {
    int num = 10;
    func(&num);
    return 0;
}
    • 这里通过给第二个模板函数添加一个默认参数，使其在匹配 &num 时成为更好的选择。
  2. 对象切片问题
    • 问题：如果传入派生类对象给 func，并且 func 中对 param 进行操作时，可能会发生对象切片。例如：
    class Base {
public:
    virtual void print() {
        std::cout << "Base" << std::endl;
    }
};
class Derived : public Base {
public:
    void print() override {
        std::cout << "Derived" << std::endl;
    }
};
template <typename T>
void func(const T& param) {
    param.print();
}
int main() {
    Derived d;
    func(d);
    return 0;
}
    • 如果 T 被推导为 Derived，由于 param 是 const T&，param.print() 会调用 Base 类的 print 函数，发生对象切片。
    • 解决：使用 const_cast 去除 const 限定（需谨慎使用）或者在 func 中使用 static_cast 等进行动态类型转换（如果合适）。例如：
    class Base {
public:
    virtual void print() {
        std::cout << "Base" << std::endl;
    }
};
class Derived : public Base {
public:
    void print() override {
        std::cout << "Derived" << std::endl;
    }
};
template <typename T>
void func(const T& param) {
    const_cast<T&>(param).print();
}
int main() {
    Derived d;
    func(d);
    return 0;
}
    • 这里通过 const_cast 去除 param 的 const 限定，使得 print 函数可以正确调用 Derived 类的版本。但要注意 const_cast 的使用场景，避免引发未定义行为。

利用这些机制实现高效泛型编程

  1. 代码复用
    • 模板函数 func 可以接受各种类型的参数，避免了为每种类型编写重复的函数。例如，对于不同类型的打印操作：
    #include <iostream>
#include <string>
template <typename T>
void func(const T& param) {
    std::cout << param << std::endl;
}
int main() {
    int num = 10;
    std::string str = "Hello";
    func(num);
    func(str);
    return 0;
}
    • 这样可以复用 func 函数的代码逻辑，提高代码的可维护性和复用性。
  2. 性能优化
    • 由于使用 const T& 作为参数，避免了不必要的对象拷贝。对于大型对象，这可以显著提高性能。例如：
    #include <iostream>
#include <vector>
template <typename T>
void func(const T& param) {
    // 对 param 进行操作，这里不进行拷贝
    std::cout << "Size of vector: " << param.size() << std::endl;
}
int main() {
    std::vector<int> vec = {1, 2, 3, 4, 5};
    func(vec);
    return 0;
}
    • 如果 func 的参数是 T param，则会对 vec 进行拷贝，而使用 const T& 避免了这种开销，实现了高效的泛型编程。