C++ template function for arrays, vectors, built in types, STL

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<

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!

Answer 2

I believe you're mixing two things in one class, which should be avoided: As far as I can see, what your class is about (its "responsibility") is to write data to a file. Another thing you're adding is knowledge about iterating collections of data.

Take a look at STL's <algorithm> methods:

http://www.cplusplus.com/reference/algorithm/

There you can find generic ways of iterating data, e.g. in the find method:

template<class InputIterator, class T>
  InputIterator find ( InputIterator first, InputIterator last, const T& value )
  {
    for ( ;first!=last; first++) if ( *first==value ) break;
    return first;
  }

This makes you independent from whether you are using vector, list, arrays or whatever.

If you also want to serialize things like vector<vector<T> > (note the space between the two >!), you have to explain more on what you want to do with such data. Simply concat the elements as if all Ts were in one vector? In this case you might try to create a new iterator which does exactly this.

The boost iterator library could help with this:

http://www.boost.org/doc/libs/1_48_0/libs/iterator/doc/index.html