Question

The current specifications is:

Given string data in the form of wide or narrow character arrays write the functionality for a class that provides statistics on the data and modifies the data.

The requirement is for it to be maintainable over the long term.

So my first approach is to require the raw char arrays be marshalled into strings prior, then just provide a template class:

template<class T>
class MyString
{
private:
    T _data;
public:
    MyString(T& input) { _data = input; }; 
    size_t doSomeWork() { //assume T is of type basic_string<...> and use iterators };

};


//Use
const char* data = "zyx";
string blahblah(data);
MyString<string> abc(blahblah);
abc.doSomeWork();

or static member functions:

class StringTools
{
public:
    static size_t doWork(const char*) {}
    static size_t doWork(const wchar_t*) {}
};

//used like so:
const char* data = "hallo kitty";
cout << StringTools::doWork(data);

or use a strategy pattern:

class MyString
{
protected:
    MyStringBase();
public:
    virtual ~MyStringBase();    
    virtual size_t doWork() = 0;
};

class MyStringCharArray : public MyString
{
protected:
    char* _data;
public:
    MyStringCharArray(const char* input) : MyString() { }
    virtual size_t doWork() {...};
};

//so it would be used like so
const char* blah = "blah";
MyString* str = new MyStringCharArray(blah);
cout << str->doWork();
delete str;

and then in the future if for some god forsaken reason i switch to BStr’s then it would only require that the first two lines of code be changed in addition to a new derived class being written.

I think that if i write a wrapper class as in 1 & 3 it becomes alot more heavy duty and any encapsulation is broken as i’d have to allow access to the underlying.

but if i create a class with only static functions then all it does is mimic a namespace which would be better served by some non-member non-friend functions encapsulated under a
“stringtools” namespace. But then i’d still be propagating the messyness of raw character arrays throughout the application and extra validation would have to be performed etc and the specification
asked explicitly for a class.

So what would be the cleanest and most maintainable approach to take?

rgds

Answer 1

The best approach would be to do something like what stl algorithms do.

Have a process algorithm that only takes the string char/wchart_t begin and end iterator. This way you algorithm will seamlessly work for all strings that can contiguous in memory.