函数根据返回值左/右值引用调整行为？及Result类多类型适配问询

当然可以！C++11及以后的标准提供了几种直观的机制来实现这个需求，最常用的是引用限定的成员函数（ref-qualified member functions），另外也可以通过重载转换运算符或代理类来实现。

举个最直接的例子：我们给类的成员函数加上&（左值限定）和&&（右值限定）版本，这样当函数返回的对象是左值（比如被赋值给变量后使用）时，会调用左值版本的成员；是右值（比如临时对象直接使用）时则调用右值版本：

class MyResult {
public:
    // 左值版本：适合需要保留内部状态的场景，比如返回不可修改的引用
    const std::string& get_value() const& {
        std::cout << "处理左值场景\n";
        return value_;
    }

    // 右值版本：可以安全移动内部资源，避免不必要的拷贝
    std::string get_value() && {
        std::cout << "处理右值场景\n";
        return std::move(value_);
    }

private:
    std::string value_ = "hello world";
};

MyResult create_result() {
    return MyResult{};
}

// 测试场景
int main() {
    MyResult lval = create_result();
    lval.get_value(); // 输出：处理左值场景

    create_result().get_value(); // 输出：处理右值场景
}

如果你的需求是在转换到其他类型时区分左值/右值，还可以给转换运算符加上引用限定：

class MyResult {
public:
    operator std::string() const& {
        std::cout << "左值转string\n";
        return value_;
    }

    operator std::string() && {
        std::cout << "右值转string\n";
        return std::move(value_);
    }

private:
    std::string value_ = "hello world";
};

这样临时返回的Result对象直接转string时，会触发右值版本，允许移动内部资源，而左值转换则会执行拷贝逻辑。

针对你的场景——包装中等开销的内部对象、支持多类型输出，核心优化方向是避免不必要的资源拷贝/重复计算，同时保证内存安全。这里提供几个实用的设计思路：

1. 用引用限定的转换函数区分左值/右值 #

延续问题1的思路，给每个转换方法加上const&和&&限定：当Result是右值时，可以直接消耗内部对象（比如提前释放资源），而左值场景则保留内部状态供后续使用。

同时推荐用std::unique_ptr替代裸指针管理内部资源，避免手动内存管理的错误：

#include <memory>
#include <string>

class ExpensiveInternalObject {
public:
    std::string to_string() const { /* 中等开销的字符串转换逻辑 */ }
    int to_int() const { /* 中等开销的整数转换逻辑 */ }
    // 其他需要的转换方法...
};

class Result {
public:
    static Result compute(/* args */) {
        Result result;
        result.fData = std::make_unique<ExpensiveInternalObject>(/* args */);
        return result;
    }

    // 左值版本：保留内部对象，供后续多次转换使用
    std::string to_string() const& {
        return fData->to_string();
    }

    int to_int() const& {
        return fData->to_int();
    }

    // 右值版本：转换后直接释放内部资源，避免后续析构的开销
    std::string to_string() && {
        std::string res = fData->to_string();
        fData.reset(); // 提前释放资源
        return res;
    }

    int to_int() && {
        int res = fData->to_int();
        fData.reset();
        return res;
    }

    // 禁用拷贝（内部资源是独占的），允许移动（unique_ptr自动生成安全的移动语义）
    Result(const Result&) = delete;
    Result& operator=(const Result&) = delete;

    Result(Result&&) = default;
    Result& operator=(Result&&) = default;

private:
    Result() = default;
    std::unique_ptr<ExpensiveInternalObject> fData;
};

2. 缓存转换结果（避免重复计算） #

如果客户端可能多次将同一个Result对象转换为同一类型，缓存转换结果可以避免重复执行中等开销的操作：

class Result {
public:
    // ... 之前的compute、移动语义等 ...

    std::string to_string() const& {
        if (!cached_string) {
            cached_string = std::make_unique<std::string>(fData->to_string());
        }
        return *cached_string;
    }

    int to_int() const& {
        if (!cached_int) {
            cached_int = std::make_unique<int>(fData->to_int());
        }
        return *cached_int;
    }

private:
    std::unique_ptr<ExpensiveInternalObject> fData;
    mutable std::unique_ptr<std::string> cached_string; // mutable允许const函数修改
    mutable std::unique_ptr<int> cached_int;
};

3. 优先使用显式转换函数而非隐式转换 #

虽然隐式转换运算符很方便，但显式的命名转换函数（比如to_string()、to_int()）可读性更强，能减少意外的类型转换错误，也更符合现代C++的编码风格。

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