C风格字符串右值实例化模板类触发返回数组编译错误，求通用解法

问题根源 #

当用字符串字面量（如"hello"）实例化impNode时，模板参数dataType会被推导为对应长度的字符数组类型（比如char[6]）。而C++禁止函数返回数组类型，所以dataType getData()这一行会触发编译错误。逐个特化不同长度的数组显然不现实，以下是几种通用解决方案：

方案1：动态调整getData()的返回类型 #

利用C++17的constexpr if和类型萃取工具，让getData()在数组类型时返回指针，普通类型时返回原类型，无需特化：

#include <type_traits>
#include <iostream>

template<class dataType>
class impNode 
{
private:
    dataType _data;
public:
    explicit impNode(const dataType &data) : _data(data) { 
        std::cout << "this constructor is called!" << std::endl; 
    };
    virtual ~impNode() { };
    
    // 根据dataType是否为数组，确定返回类型
    using ReturnType = typename std::conditional_t<
        std::is_array_v<dataType>,
        std::remove_all_extents_t<dataType>*,
        dataType
    >;
    
    ReturnType getData() { 
        if constexpr (std::is_array_v<dataType>) {
            return _data; // 数组隐式转换为指针
        } else {
            return _data;
        }
    };
};

// 测试代码
int main(int, char**) 
{
    impNode a{98}; 
    impNode b{false};
    impNode c{"hello"}; // 无需特化，正常编译
    
    // 验证返回值
    auto str_ptr = c.getData();
    std::cout << str_ptr << std::endl; // 输出hello
    return 0;
}

优点：保留数组的本地存储（字符串内容会被拷贝到_data中），无悬垂指针风险；无需额外特化代码。
缺点：数组类型的返回值是指针，调用者需要注意其指向的是对象内部的数组，不能在对象销毁后使用。

方案2：将数组类型衰减为指针 #

通过std::decay让模板参数推导为指针类型而非数组，从根源避免数组返回的问题：

#include <type_traits>
#include <iostream>

// 实现类，处理衰减后的类型
template<typename dataType>
class impNodeImpl {
private:
    dataType _data;
public:
    explicit impNodeImpl(const dataType &data) : _data(data) { 
        std::cout << "this constructor is called!" << std::endl; 
    };
    virtual ~impNodeImpl() { };
    
    dataType getData() { 
        return _data; 
    };
};

// 对外暴露的类，自动衰减输入类型
template<typename T>
class impNode : public impNodeImpl<std::decay_t<T>> {
public:
    using impNodeImpl<std::decay_t<T>>::impNodeImpl;
};

// 测试代码
int main(int, char**) 
{
    impNode a{98}; 
    impNode b{false};
    impNode c{"hello"}; // dataType被推导为const char*
    
    auto str_ptr = c.getData();
    std::cout << str_ptr << std::endl; // 输出hello
    return 0;
}

优点：代码简洁，无需处理数组特殊逻辑；所有类型统一按衰减后的类型处理。
缺点：存储的是字符串字面量的指针，若传入的是局部字符数组，对象销毁后指针会悬垂，仅适合字符串字面量这类生命周期全局的场景。

方案3：统一转换为std::string存储 #

针对所有C风格字符串，自动转换为std::string存储，彻底避免数组和指针的问题：

#include <string>
#include <iostream>

template<class dataType>
class impNode 
{
private:
    dataType _data;
public:
    explicit impNode(const dataType &data) : _data(data) { 
        std::cout << "this constructor is called!" << std::endl; 
    };
    virtual ~impNode() { };
    
    dataType getData() { 
        return _data; 
    };
};

// 偏特化所有const char数组类型，自动转std::string
template<std::size_t N>
class impNode<const char[N]> : public impNode<std::string> {
public:
    explicit impNode(const char (&data)[N]) : impNode<std::string>(std::string(data)) {
        std::cout << "C-style string converted to std::string!" << std::endl;
    }
};

// 测试代码
int main(int, char**) 
{
    impNode a{98}; 
    impNode b{false};
    impNode c{"hello"}; // 自动匹配偏特化，转成std::string存储
    
    auto str = c.getData();
    std::cout << str << std::endl; // 输出hello
    return 0;
}

优点：最安全，std::string管理内存，无悬垂指针问题；支持任意长度的C风格字符串，无需逐个特化。
缺点：会产生字符串拷贝，对性能敏感场景需权衡；存储的是std::string而非原数组类型，若需要严格保留数组类型则不适用。

内容的提问来源于stack exchange，提问作者Juan_David