扩展向量迭代器以访问所包含的类/结构的数据成员

Question

So, I have a class that does string manipulation based on metadata attached to each character in the string. Internally, I represent this with a std::vector<CharacterType> where CharacterType contains, among other things, the character in question. This internal representation is useful to me, but at the end of the manipulation(s) the class user is interested in the string itself.

In order to do this, I decided to extend std::vector<CharacterType>::iterator to include an operator*() method that returns a character rather than a CharacterType . Here's the code, it works in Visual Studio 2008 on Windows 7. But is it idiomatic C++? I haven't written much C++ since the 90s, so I'd appreciate some feedback on the style or if I'm doing something dangerous and/or evil. (In the code below I made a simplified CharacterType structure called mytype -- in reality the structure is quite a bit bigger.)

#include <iostream>
#include <vector>
#include <string>

struct mytype {
    char c;
};

class myit : public std::vector<mytype>::iterator {
public:
    inline myit(std::vector<mytype>::iterator const &c)
        : std::vector<mytype>::iterator(c) {}
    char operator*() {
        const mytype &p =
            std::vector<mytype>::iterator::operator*();
        return p.c;
    }

    // Added these in a later edit, after thinking about a comment below
    typedef char value_type;
    typedef char *pointer;
    typedef char &reference;

private:
};

int
main()
{
    mytype test[] = { {'a'}, {'b'}, {'c'}, {'d'} };
    std::vector<mytype> vec(&test[0], &test[4]);
    myit i(vec.begin()), e(vec.end());
    std::string str(i, e);

    std::cout << str << std::endl;
    return 0;
}

Assuming this is good style, is it appropriate to use C++ type-aware method overloading to have several operator*() methods in myit so that I can use the same iterator class to get another member of a different type? Or would it be better to use a template? For example, one piece of metadata is the character's language, and I would like to be able to extract a std::vector<LanguageType> in exactly the same way. Thoughts?

Also, since the methods that return these data don't affect the object's internal representation, in the interest of const correctness I would like to be able to define the accessors const . This probably means that I'd need to modify the above to use a const_iterator instead, but I haven't gotten to that yet.

Thanks for your style critiques in advance!

Answer 1

first of all, I would also like to be able to write so good C++ after such a long break, if it should ever happen to me!

said that, what are the reasons for ruling out a simple conversion operator from your CharacterType to char ? something like: CharacterType::operator char();

of course, we all know the problems with operator overloading (but that would not change in the two cases)...

about other things you ask, you cannot overload based on the return type, so you could not possibly have different operator()s for different return types, if that's what you mean.

but you could use templates for that, as you mention.

Answer 2

您不应该派生std :: vector（也不派生其他STL容器），因为它的析构函数不是虚拟的，并且您可能会遇到不调用vector的析构函数的情况，并且会发生内存泄漏。

Answer 3

I don't believe that you can have "several operator*() overloads" in the same class; presumably you would want to disambiguate based on return-type, but C++ does not do this.

Also, directly deriving from an unrelated iterator type may not be a great idea. In order to operate correctly as an STL iterator, an iterator class needs to define a number of typedefs, etc. None of yours will be meaningful if you directly inherit them like this. For more information, see eg this article on Custom Containers & Iterators for STL-Friendly Code .

Answer 4

You're breaking several iterator contracts by returning a type other than CharacterType from operator*() . Honestly- just give CharacterType an operator char() if you're desperate for them to be convertible.

Answer 5

A few different people suggested that I look into conversion operators, which I must admit I totally forgot about. A conversion operator based solution is considerably cleaner:

#include <iostream>
#include <vector>
#include <string>

struct mytype {
    char c;
    inline operator char () { return c; }
};

int
main()
{
    mytype test[] = { {'a'}, {'b'}, {'c'}, {'d'} };
    std::vector<mytype> vec(&test[0], &test[4]);
    std::string str(vec.begin(), vec.end());

    std::cout << str << std::endl;
    return 0;
}

... and it doesn't involve me worrying about ominous sounding things like violating STL iterator contracts. Plus, it seems (although I haven't tried it yet) that if I want to be able to easily copy something other than the string (the std::vector<LanguageType> idea in my original question) I can extend this easily by just adding a different cast operator, whereas the iterator derivation technique would have required much more boilerplate, since there is no return type polymorphism in C++, as several people pointed out to me.

Thanks a lot for your responses, once I get the rep to do it I will upvote you all, in case you're wondering why I haven't yet.