Thread: some design questions

If you have a class customer (for instance) which has a container std::vector<std::string> that stores customer's nicknames and you want to access it from other classes so that you can get the first nickname in the list, x-th name in the list and you want to be able to add nicknames to the list - how would you implement it?

Perhaps you could write something like this:

Code:

class customer {
public:
    typedef std::vector<std::string>::size_type size_type;

    void add_nickname(const std::string& nickname)
    {
        m_nicknames.push_back(nickname);
    }

    std::string get_nickname(size_type n) const
    {
        return m_nicknames[n];
    }

    size_type num_nicknames() const
    {
        return m_nicknames.size();
    }
private:
    std::vector <std::string> m_nicknames;
};

After all, if you want to know what is the first nickname, you can just call customer_obj.get_nickname(0).

Maybe using boost:: optional would be better for get_nickname functions (because list could be empty) ?

You could simply require the caller to check that the customer has nicknames before trying to access the nicknames. This could be enforced by returning m_nicknames.at(n) instead so as to throw an out_of_range exception if necessary.

What do you think about those long function names? On one side it is sensible so you can be sure what function does, on other side it doesnt 'look good'..

The "customer" seems unnecessary since this is with respect to a class named customer.

Well, I think it looks like a sensible implementation. Although the get functions could probably return a const reference to avoid copying. And they should probably be const too.
I wouldn't be that worried about long function names. It's better they're descriptive than short and undescriptive. There's a file line, of course, but I think this is alright. Or you could shorten them to get_first_nicknname, get_nickname, etc.

I think returning a const reference or a copy of the local vector is good for get, and then you can keep your add function. If the vector is empty the user of the class can just check the returned vector, and if they want to iterate through it they can do that themselves. However, you would still be encapsulating the modification of the vector.

hmm... that brings to mind something: returning a const reference or a copy of the local vector fixes the underlying implementation to a vector (unless one wants to waste time with some kind of translation to a vector). In view of an assumption that "the other code needs to iterate through the list of nicknames", it may be better in such a case to return an iterator instead, e.g.,

Code:

class customer {
public:
    typedef std::vector<std::string>::const_iterator const_nickname_iterator;

    void add_nickname(const std::string& nickname)
    {
        m_nicknames.push_back(nickname);
    }

    const_nickname_iterator nickname_begin() const
    {
        return m_nicknames.begin();
    }

    const_nickname_iterator nickname_end() const
    {
        return m_nicknames.end();
    }
private:
    std::vector<std::string> m_nicknames;
};