非模板容器迭代器

Question

Let's suppose we have a class Container without a template, and the functions begin() and end() , witch returns a class Container_iterator . The Container class has a map in it:

class Container
{
    Container_iterator begin();
    Container_iterator end();
};
class Container_iterator
{
    Container operator*();
}

Now, this code does not compile, so we add the forward declerations of the classes. However, in the code still does not compile, saying that Container is a incomplete type. Is there any way to get the code to compile, or is implementing iterators without templates not possible?

Edit: code

namespace json
{
    class JSONobj
    {
        void* to_value;
        json_types t;

    public:
        typedef std::unordered_map<std::string, JSONobj> json_obj;


        // iterator class
        class iterator : std::iterator < std::forward_iterator_tag, JSONobj, size_t>
        {
        public:

        private:
            json_array::iterator it_array;
            json_obj::iterator it_obj;
            json_iterator_types t;

        public:
            iterator(JSONobj::json_array::iterator& _it_array);

            // prefix ++ operator
            iterator& operator++();

            // suffix ++ operator
            iterator& operator++(int);


            std::string key();
            // dereferance operator
            reference operator*();
        };

        inline reference front() {}
        inline reference back() {}
    }
}

Answer 1

You can just make Container_iterator a nested type member of Container , and it'll work:

class Container
{
  class Container_iterator
  {
     Container operator*();
  };

  Container_iterator begin();
  Container_iterator end();
};

Also, it seems odd that an iterator would return a Container instead of an element of the Container , but the solution above would work in that case as well.

Answer 2

Is there any way to get the code to compile

Simply declare the classes before using the declaration. And add the missing semicolon.

Defining the iterator as nested class as suggested in cigien's answer is conventional and I recommend that approach. But it is not strictly necessary.

However, in the code still does not compile

Yes it does .

saying that Container is a incomplete type.

This is not something that can be solved with a forward declaration. This means that you are using the definition of the class before that definition.

This is an error that is not produced in your example since the definition of Container is not used.

This error can be fixed by ordering the code differently such that the class is defined before its definition is used.