C++中如何从基类Object返回派生类String？解决类型依赖问题

假设有基类Object包含ToString方法，该方法需要返回继承自Object的String类：

class Object
{
 public:
    String ToString() const
    {
        // 基础实现返回类似"Object"的字符串
    }
};

class String : public Object
{
 public:
    String ToString() const // 覆写基类方法
    {
        // 返回字符串的实际内容
    }
};

编译时会遇到循环依赖问题：定义Object时，String还是不完全类型，无法作为值返回类型。尝试过C20模块拆分，但仍无法解决类型识别问题。部分语言支持延迟处理未知类型，C中是否有类似的实现方式？

1. 前向声明+指针/引用返回（最直接的修改） #

C++允许对不完全类型使用指针或引用，但不能直接返回值（编译器需要知道类型大小）。通过前向声明String，并修改返回类型为指针或引用，可打破依赖：

// 前向声明String，此时String是不完全类型
class String;

class Object
{
 public:
    // 声明虚函数，返回const引用
    virtual const String& ToString() const;
};

// 定义String类（此时Object已完整定义）
class String : public Object
{
 private:
    const char* m_data;
 public:
    String(const char* data) : m_data(data) {}
    
    const String& ToString() const override
    {
        return *this; // 返回自身作为字符串表示
    }

    // 辅助方法，用于获取C风格字符串
    const char* c_str() const { return m_data; }
};

// 实现Object的ToString方法（此时String已完整定义）
const String& Object::ToString() const
{
    static String obj_str("Object");
    return obj_str;
}

如果选择返回指针，建议使用智能指针（如std::unique_ptr）避免内存泄漏：

#include <memory>

class String;

class Object
{
 public:
    virtual std::unique_ptr<String> ToString() const;
};

// ... String定义同上 ...

std::unique_ptr<String> Object::ToString() const
{
    return std::make_unique<String>("Object");
}

2. 引入抽象接口层 #

定义一个独立的IString抽象类，让Object返回该接口类型，String同时继承Object和IString，彻底解耦两者的直接依赖：

// 抽象字符串接口，不依赖任何类
class IString
{
 public:
    virtual ~IString() = default;
    virtual const char* c_str() const = 0;
};

class Object
{
 public:
    virtual std::unique_ptr<IString> ToString() const
    {
        // 内部实现一个临时的IString子类
        class ObjectString : public IString
        {
            const char* c_str() const override { return "Object"; }
        };
        return std::make_unique<ObjectString>();
    }
};

// String同时继承Object和IString
class String : public Object, public IString
{
 private:
    const char* m_data;
 public:
    String(const char* data) : m_data(data) {}
    
    std::unique_ptr<IString> ToString() const override
    {
        return std::make_unique<String>(m_data);
    }

    const char* c_str() const override { return m_data; }
};

3. CRTP模板化基类（适合允许模板重构的场景） #

利用奇异递归模板模式（CRTP），将Object改为模板类，让派生类作为模板参数传入，延迟类型绑定：

template<typename Derived>
class Object
{
 public:
    Derived ToString() const
    {
        return Derived("Object");
    }
};

// String继承模板化的Object<String>
class String : public Object<String>
{
 private:
    const char* m_data;
 public:
    String(const char* data) : m_data(data) {}
    
    // 覆写基类方法（此时Derived即String已完整定义）
    String ToString() const
    {
        return *this;
    }

    const char* c_str() const { return m_data; }
};

这种方式会改变Object的设计（变为模板类），适合可以接受模板化基类的场景。

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