Is there a base class from which all members of the C++ standard library derive?

Question

C++/CLI has a System::Object class to serve this purpose, but I can't seem to find one in the standard library. Basically I'm writing a set of classes, and I would like the base class to store a vector of std::stringin a content property, but derived classes might need to store a vector of something else (perhaps even one of my own classes). It might seem like an odd goal, but I'm writing a some file access classes to let me more easily manipulate files of different formats. The base File class will store each line in a string, as part of the vector - but a class for JSON, for instance, might need to store JS-Style collections/objects, etc.

The only way I could think to do this is to have the content property a vector of objects (or some other universal base class - I can derive any custom classes from it for polymorphism's sake too) and then cast it back into whatever type is necessary depending on the type of child object that is being used. I soon discovered that I couldn't find any mention of std::object (or similar) anywhere.

This example should demonstrate what I'm trying to do:

class File {
protected:
    std::vector<std::object> _content;

public:
    //Contructors/methods/etc.

    std::string getItemAt(size_t index) {
        return static_cast<std::string>(this->_content[index]);
    }

    void setItemAt(size_t index, std::string value) {
        this->_content[index] = static_cast<std::object>(value);
    }
};

class JSONFile: File {
public:
    //Constructors/methods/etc.

    SomeObject getItemAt(size_t index) {
        return static_cast<SomeObject>(this->_content[index]);
    }

    void setItemAt(size_t index, SomeObject value) {
        this->_content[index] = static_cast<std::object>(value);
    }
};

Note that this example assumes that std::object exists, and that SomeObject would be whatever is used to handle the JSON (again, for example - this could be anything) data. SomeObject would obviously derive from std::object.

Any suggestions would be greatly appreciated, or if I'm going completely the wrong way about this, any feedback as to how I could do it so that the std::object thing isn't necessary would be greatly appreciated :)

Answer 1

No.

Because C++ is all about "you only pay for what you use".

What would the interface of std::object look like? If there were any member functions, those would have to be virtual to be of any use, resulting in a runtime cost because of dynamic dispatch.

If the hypothetical std::object was an empty class, what could you do with a std::object reference? Not much, since it wouldn't have any member functions to call. Why make everything derive from a single base when they have nothing in common.

---

If you really need a base for all of your classes, you can always write one. But note that doing so might not be a good design decision.

Answer 2

Is there a base class from which all members of the C++ standard library derive?

The short answer is "No."
The long answer is "Definitely not."

An answer that provides more details can be seen at a related SO site: Why is base-for-all-objects discouraged in C++.

Answer 3

When I see you define

std::vector<std::object> _content;

it tells me that your goal is to rather do generic programming with templates than object oriented programming with inheritance. This is the same style of std::vector and co., so it shouldn't look too unfamiliar.

Your code could be:

template <typename FileObject>
class File {
public:
    std::vector<FileObject> _content;

public:
    //Constructors/methods/etc.

    FileObject getItemAt(size_t index) {
        return this->_content[index];
    }

    void setItemAt(size_t index, std::string value) {
        this->_content[index] = FileObject(value);
    }
};

then use it as

json_files = File<JSONObject>();
json_files.setItemAt(1, "{}");

or if you have special operations you want to perform on your json object list, the function can take an explicit File<JSONObject> parameter. It's also possible to inherit from File<JSONObject>, but mixing and matching OO/Generic is discouraged.

Now, closer to your title question: you can't easily store different File types in the same vector, but think about how you would implement that. What are the storage requirements for File<int>? For File<double>? This is a core spot where your OO/inheritance solution will become ungainly and using generic programming makes it impossible to try, which is good.