Частичная специализация
От: gid_vvp  
Дата: 28.10.05 13:26
Оценка: :)
Hi All.

вот есть нечто такое
оно компилируется и работает правильно.
Но если я пытаюсь сделсть чстичную специализацию то компилятор ругается

error C2079: 'Container<T>::CUserIterator<D,I>::inc' uses undefined class 'Container<T>::Increment<UserIterator,Iterator>'

#include "stdafx.h"
#include <iostream>

struct DataType1
{
    int data;
};

struct DataType2
{
    int data1;
    int data2;
};

template<typename T>
class Container
{
public:
    template<typename D, typename I>
    class CUserIterator;

    typedef CUserIterator<DataType1, char*>    Data1IteratorType;
    typedef CUserIterator<DataType2, char*>    Data2IteratorType;

    template<typename UserIterator, typename Iterator>
    class Increment;
    template<typename UserIterator, typename Iterator>
    class Decrement;

    //template<typename Iterator>    
    //class Increment<Data1IteratorType, Iterator>
    template<>    
    class Increment<Data1IteratorType, char*>
    {
    public:
        //void operator()(Iterator& iter)
        void operator()(char*& iter)
        {
            std::cout << "Increment<CUserIterator<DataType1> >::operator(){++iter;}" << std::endl;
            ++iter;
        }
    };

    //template<typename Iterator>    
    //class Decrement<Data1IteratorType, Iterator>
    template<>    
    class Decrement<Data1IteratorType, char*>
    {
    public:
        //void operator()(Iterator& iter)
        void operator()(char*& iter)
        {
            std::cout << "Decrement<CUserIterator<DataType1> >::operator(){--iter;}" << std::endl;
            --iter;
        }
    };


    //template<typename Iterator>    
    //class Increment<Data2IteratorType, Iterator>
    template<>    
    class Increment<Data2IteratorType, char*>
    {
    public:
        //void operator()(Iterator& iter)
        void operator()(char*& iter)
        {
            std::cout << "Increment<CUserIterator<DataType2> >::operator(){++iter;}" << std::endl;
            ++iter;
        }
    };


    //template<typename Iterator>    
    //class Decrement<Data2IteratorType, Iterator>
    template<>    
    class Decrement<Data2IteratorType, char*>
    {
    public:
        //void operator()(Iterator& iter)
        void operator()(char*& iter)
        {        
            std::cout << "Decrement<CUserIterator<DataType2> >::operator(){--iter;}" << std::endl;
            --iter;
        }
    };

    template<typename D, typename I>
    class CUserIterator
    {
    public:

        CUserIterator&    operator++()
        {
            inc(iter);

            return (*this);
        }

        CUserIterator& operator--()
        {    
            dec(iter);

            return (*this);
        }

    private:
        Increment<CUserIterator<D, I>, I > inc;
        Decrement<CUserIterator<D, I>, I > dec;

        I iter;
    };

    void Test(void)
    {
        Data1IteratorType it1;
        ++it1;
        --it1;
        Data2IteratorType it2;
        ++it2;
        --it2;
    }
};

int _tmain(int argc, _TCHAR* argv[])
{
    Container<int> c;
    c.Test();

    return 0;
}
... << RSDN@Home 1.1.4 stable SR1 rev. 568>>
Re: Частичная специализация
От: crable США  
Дата: 28.10.05 14:38
Оценка: 3 (1)
Здравствуйте, gid_vvp, Вы писали:

_>Hi All.


_>вот есть нечто такое

_>оно компилируется и работает правильно.
_>Но если я пытаюсь сделсть чстичную специализацию то компилятор ругается

_>error C2079: 'Container<T>::CUserIterator<D,I>::inc' uses undefined class 'Container<T>::Increment<UserIterator,Iterator>'


_>
_>#include "stdafx.h"
_>#include <iostream>

_>struct DataType1
_>{
_>    int data;
_>};

_>struct DataType2
_>{
_>    int data1;
_>    int data2;
_>};

_>template<typename T>
_>class Container
_>{
_>public:
_>    template<typename D, typename I>
_>    class CUserIterator;

_>    typedef CUserIterator<DataType1, char*>    Data1IteratorType;
_>    typedef CUserIterator<DataType2, char*>    Data2IteratorType;

_>    template<typename UserIterator, typename Iterator>
_>    class Increment;
_>    template<typename UserIterator, typename Iterator>
_>    class Decrement;

_>    //template<typename Iterator>    
_>    //class Increment<Data1IteratorType, Iterator>
_>    template<>    
_>    class Increment<Data1IteratorType, char*>
_>    {
_>    public:
_>        //void operator()(Iterator& iter)
_>        void operator()(char*& iter)
_>        {
_>            std::cout << "Increment<CUserIterator<DataType1> >::operator(){++iter;}" << std::endl;
_>            ++iter;
_>        }
_>    };

_>    //template<typename Iterator>    
_>    //class Decrement<Data1IteratorType, Iterator>
_>    template<>    
_>    class Decrement<Data1IteratorType, char*>
_>    {
_>    public:
_>        //void operator()(Iterator& iter)
_>        void operator()(char*& iter)
_>        {
_>            std::cout << "Decrement<CUserIterator<DataType1> >::operator(){--iter;}" << std::endl;
_>            --iter;
_>        }
_>    };


_>    //template<typename Iterator>    
_>    //class Increment<Data2IteratorType, Iterator>
_>    template<>    
_>    class Increment<Data2IteratorType, char*>
_>    {
_>    public:
_>        //void operator()(Iterator& iter)
_>        void operator()(char*& iter)
_>        {
_>            std::cout << "Increment<CUserIterator<DataType2> >::operator(){++iter;}" << std::endl;
_>            ++iter;
_>        }
_>    };


_>    //template<typename Iterator>    
_>    //class Decrement<Data2IteratorType, Iterator>
_>    template<>    
_>    class Decrement<Data2IteratorType, char*>
_>    {
_>    public:
_>        //void operator()(Iterator& iter)
_>        void operator()(char*& iter)
_>        {        
_>            std::cout << "Decrement<CUserIterator<DataType2> >::operator(){--iter;}" << std::endl;
_>            --iter;
_>        }
_>    };

_>    template<typename D, typename I>
_>    class CUserIterator
_>    {
_>    public:

_>        CUserIterator&    operator++()
_>        {
_>            inc(iter);

_>            return (*this);
_>        }

_>        CUserIterator& operator--()
_>        {    
_>            dec(iter);

_>            return (*this);
_>        }

_>    private:
_>        Increment<CUserIterator<D, I>, I > inc;
_>        Decrement<CUserIterator<D, I>, I > dec;

_>        I iter;
_>    };

_>    void Test(void)
_>    {
_>        Data1IteratorType it1;
_>        ++it1;
_>        --it1;
_>        Data2IteratorType it2;
_>        ++it2;
_>        --it2;
_>    }
_>};

_>int _tmain(int argc, _TCHAR* argv[])
_>{
_>    Container<int> c;
_>    c.Test();

_>    return 0;
_>}
_>


Для начала, вынеси специализацию за пределы класса.
The last good thing written in C was Franz Schubert's Symphony No. 9.
Re[2]: Частичная специализация
От: gid_vvp  
Дата: 28.10.05 15:06
Оценка:
Здравствуйте, crable, Вы писали:

C>Для начала, вынеси специализацию за пределы класса.


Точно! И ведь знал же.. Но забыл
... << RSDN@Home 1.1.4 stable SR1 rev. 568>>
Re: Частичная специализация
От: igna Россия  
Дата: 28.10.05 15:07
Оценка:
Здравствуйте, gid_vvp, Вы писали:

_>оно компилируется и работает правильно.


Что именно? Хотелось бы посмотреть на компилируемый текст.
Re[2]: Частичная специализация
От: gid_vvp  
Дата: 28.10.05 15:23
Оценка:
Здравствуйте, igna, Вы писали:

I>Здравствуйте, gid_vvp, Вы писали:


_>>оно компилируется и работает правильно.


I>Что именно? Хотелось бы посмотреть на компилируемый текст.


Это компилируемый текст

Спасибо за беспокойство, но проблема решена уже, выше.
... << RSDN@Home 1.1.4 stable SR1 rev. 568>>
 
Подождите ...
Wait...
Пока на собственное сообщение не было ответов, его можно удалить.