Question

I would like to make a class that has a function that saves the data sent to it, to a text file. The data that can be passed to it can be anything like a std::string, int, double, float, unsigned int, etc., and can also be an: std::vector<T>, T[], and std::vector<std::vector<T>>, T[][].

Now, obviously if it is an array, I will need to iterate through it to send the data to text-file.

I was thinking of using templates, but I’m not sure how to do the arrays.

Is this the way to go?

class CMyClass
{
    template<typename T>
    void SaveData(T data);
    void SaveData(std::vector<T> data);
    void SaveData(std::string data);
    void SaveData(T* data);                // Perhaps I'll also need to pass in the size.
    void SaveData(std::vector<std::vector<T>> data);
    void SaveData(T** data);
};

I imagine that the code for the std::string would be the same as the code for the std::vector<T> provided that T is a built in type (like an int or float or something).

And then I write the functions for each of the SaveData(...) accordingly?

Answer 1

First, you can either template the class or the functions. Since you want to do arrays as well, you must go with the latter option. Example follows:

class CMyClass
{
public:
    template<typename T> void SaveData(const T &data);
    template<typename T, size_t N> void SaveData(const T (&data)[N]);
    template<typename T, size_t N, size_t M> void SaveData(const T (&data)[N][M]);
    template<typename T> void SaveData(const std::vector<T> &data);
    template<typename T> void SaveData(const std::vector<std::vector<T> > &data);
    void SaveData(const std::string &data);
};

Once you have defined the functions, the following example shows how you can call them:

int i;
int i1[5];
int i2[5][7];
std::vector<int> v1;
std::vector<std::vector<int> > v2;
std::string s;

CMyClass saveClass;

saveClass.SaveData<int>(i);
saveClass.SaveData<int>(i1);
saveClass.SaveData<int>(i2);
saveClass.SaveData<int>(v1);
saveClass.SaveData<int>(v2);
saveClass.SaveData(s);

Depending on your requirements, you could make the class a singleton and the functions static, omitting the need to instantiate CMyClass at all and simply calling the functions as follows:

CMyClass::SaveData<int>(i);
CMyClass::SaveData<int>(i1);
CMyClass::SaveData<int>(i2);
CMyClass::SaveData<int>(v1);
CMyClass::SaveData<int>(v2);
CMyClass::SaveData(s);

Notes:

1. The arguments should also be references (i.e. “&data” rather than “data”), so that only the reference is passed rather than performing a copy of the whole container each time you call the function.
2. I’ve explicitly declared the functions as public, assuming this is the complete class and its functions will be accessed by another class. By default, the members of a class are private.
3. Ensure that there is a space between each nested “>”.

Good luck!