vector<bool> og pointers

Jeg er ikke sikker på at jeg helt forstår din kode.

Kode 

0101
1101
1111
0011

Kode 

#include<vector>
#include<iostream>
#include<iterator>
#include <fstream>

using namespace std;

// the Grid class

template<class T>
class Grid : public vector<vector<T> >
{
    typedef typename vector<vector<T> >::iterator row_iterator;
    typedef typename vector<T>::iterator cell_iterator;

	public:

	virtual ~Grid(){}

        void
        resize(int x, int y)
        {
            vector<vector<T> >::resize(x);

            row_iterator iter = this->vector<vector<T> >::begin();
            for (;iter != this->vector<vector<T> >::end();++iter)
            {
                iter->resize(y);
            }
        }

        class iterator;
        
        iterator
        begin()
        {
            row_iterator it = this->vector<vector<T> >::begin();
            return iterator(it,it->begin());
        }


        iterator
        end()
        {
            row_iterator it = this->vector<vector<T> >::end();
            return iterator(it, it->begin()); //This element is one past the last element!
        }
};



/*-------------------------------------------------*/
// the Grid::iterator class

template<typename T>
class Grid<T>::iterator : public std::iterator<bidirectional_iterator_tag, T>
    {

    private:
        row_iterator row_iter;
        cell_iterator cell_iter;

    public:

        iterator(){}
        iterator(row_iterator ri, cell_iterator ci) : row_iter(ri), cell_iter(ci) {}


        iterator
        operator=(const iterator& rhs)
        {
            if(this == &rhs) return *this;

            cell_iter = rhs.cell_iter;
            row_iter = rhs.row_iter;
            return *this;
        }

        T&
        operator*()
        {
            return *cell_iter;
        }


        iterator&
        operator++() //prefix
        {
            if (++cell_iter == row_iter->end())
            {
                cell_iter = (++row_iter)->begin();
            }
            return *this;
        }


        bool
        operator!=(const iterator& rhs)
        {
            return (cell_iter != rhs.cell_iter || row_iter != rhs.row_iter);
        }

};


class GeoMap : public Grid<int>  //her skal ændres til bool
{
 	public:
        GeoMap(){loadSQSfile();}
        ~GeoMap(){}

		void loadSQSfile();
		void test(){cout << "All is fine!\n";}
};



void GeoMap::loadSQSfile ()
{
    ifstream SQS_file("Worldmap.sqs");

    resize(4, 4);

    int c;
    for (GeoMap::iterator iter = this->begin(); iter != this->end(); ++iter)
    {
        c = SQS_file.get();
        if (c==10) c = SQS_file.get(); //ignore the endlines!!
        *iter = bool(c-48);            // It is necessary to subtract 48 when going from char to int (ascii value)
    }
}

int main()
{
    GeoMap g;
    g.test();
    system("pause");
}

Kode 

        cell_iterator&
        operator*()
        {
            return cell_iter;
        }

jeg har en templated klasse 'Grid<T>' der arver fra std::vector<T> (det er reelt en 2d-vector, og arver altså faktisk fra std::vector<std::vector<T> > ).

Kode 

std::transform(_geomap.begin(),_geomap.end(),this->begin(),fr);

Kode 

class Layer : public Grid<int>
{
public:
    Layer(GeoMap _geomap)
    {
       std::transform(_geomap.begin(),_geomap.end(),this->begin(),fr)
    }
private:

//fr er en functor defineret privat:
    class fromGeoMap  
    {
    public:
        fromGeoMap():no_data(-9999){}
        T operator()(int m){if (m) return 0; else return no_data;}
    private:
        T no_data;
    };

    fromGeoMap fr;
};

Jeg er bange for at det er en "no can't do" :-(