C++ generikus program, func. spec. probléma

C++ generikus program, func. spec. probléma
2010-04-12T11:24:33+02:00
2010-04-13T12:01:49+02:00
2022-11-17T10:00:34+01:00
amman
Hali!

A múltkor ebben a témában választ kaptam, hogy tudnék két külön típusra függvényt írni.
Megírtam, VS2008 alatt tökéletesen fut, viszont a gépen ami lefordítja (a fordító gcc 4.1.2, a szabványos függvénykönyvtár GNU libc 2.9. )
nem bír vele, és ilyen hibát dob:
In file included from main.cpp:2:
/usr/lib/gcc/i486-pc-linux-gnu/4.3.4/include/g++-v4/bits/stl_iterator_base_types.h: In instantiation of 'std::iterator_traits<double>':
/usr/lib/gcc/i486-pc-linux-gnu/4.3.4/include/g++-v4/bits/stl_iterator.h:101: instantiated from 'std::reverse_iterator<double>'
stack.hpp:355: instantiated from here
/usr/lib/gcc/i486-pc-linux-gnu/4.3.4/include/g++-v4/bits/stl_iterator_base_types.h:133: error: 'double' is not a class, struct, or union type
/usr/lib/gcc/i486-pc-linux-gnu/4.3.4/include/g++-v4/bits/stl_iterator_base_types.h:134: error: 'double' is not a class, struct, or union type
/usr/lib/gcc/i486-pc-linux-gnu/4.3.4/include/g++-v4/bits/stl_iterator_base_types.h:135: error: 'double' is not a class, struct, or union type
/usr/lib/gcc/i486-pc-linux-gnu/4.3.4/include/g++-v4/bits/stl_iterator_base_types.h:136: error: 'double' is not a class, struct, or union type
/usr/lib/gcc/i486-pc-linux-gnu/4.3.4/include/g++-v4/bits/stl_iterator_base_types.h:137: error: 'double' is not a class, struct, or union type
stack.hpp:355: error: template-id 'operator-<double>' for 'Stack<double> operator-(const Stack<double>&, const Stack<double>&)' does not match any template declaration
/usr/lib/gcc/i486-pc-linux-gnu/4.3.4/include/g++-v4/bits/stl_iterator_base_types.h: In instantiation of 'std::iterator_traits<int>':
/usr/lib/gcc/i486-pc-linux-gnu/4.3.4/include/g++-v4/bits/stl_iterator.h:101: instantiated from 'std::reverse_iterator<int>'
stack.hpp:381: instantiated from here
/usr/lib/gcc/i486-pc-linux-gnu/4.3.4/include/g++-v4/bits/stl_iterator_base_types.h:133: error: 'int' is not a class, struct, or union type
/usr/lib/gcc/i486-pc-linux-gnu/4.3.4/include/g++-v4/bits/stl_iterator_base_types.h:134: error: 'int' is not a class, struct, or union type
/usr/lib/gcc/i486-pc-linux-gnu/4.3.4/include/g++-v4/bits/stl_iterator_base_types.h:135: error: 'int' is not a class, struct, or union type
/usr/lib/gcc/i486-pc-linux-gnu/4.3.4/include/g++-v4/bits/stl_iterator_base_types.h:136: error: 'int' is not a class, struct, or union type
/usr/lib/gcc/i486-pc-linux-gnu/4.3.4/include/g++-v4/bits/stl_iterator_base_types.h:137: error: 'int' is not a class, struct, or union type
stack.hpp:381: error: template-id 'operator-<int>' for 'Stack<int> operator-(const Stack<int>&, const Stack<int>&)' does not match any template declaration
ERROR: Failed to compile main.cpp
ERROR: Error in compilation skipping linking


megnéztem, és rájöttem, hogy a template spaceialization-ömmel van baja,

az osztályban így deklaráltam az adott (operator-) funkciót:

//abszolútértékes kivonás template <class U> friend Stack<U> operator-(const Stack<U>&, const Stack<U>&);

ez után a classon kívül így néz ki a definíció:

//abszolútértékes kivonás template <class U> Stack<U> operator-(const Stack<U>& a, const Stack<U>& b) { Stack<U> ret_Stack_s(a.capacity); Stack<U> ret_Stack(a.capacity); Stack<U> *n_Stack; Stack<U> a_s(a), b_s(b); while(a_s.size > 0) { ret_Stack_s.push(fabs(a_s.pop() - b_s.pop())); } //sorrend megfordítása while(ret_Stack_s.size > 0) { ret_Stack.push(ret_Stack_s.pop()); } n_Stack= new Stack<U>(ret_Stack); return *n_Stack; } //template specialization to double for operator- template <> Stack<double> operator-<double>(const Stack<double>& a, const Stack<double>& b) { Stack<double> ret_Stack_s(a.capacity); Stack<double> ret_Stack(a.capacity); Stack<double> *n_Stack; Stack<double> a_s(a), b_s(b); while(a_s.size > 0) { ret_Stack_s.push(fabs(a_s.pop() - b_s.pop())); } //sorrend megfordítása while(ret_Stack_s.size > 0) { ret_Stack.push(ret_Stack_s.pop()); } n_Stack= new Stack<double>(ret_Stack); return *n_Stack; } //template specialization to int for operator- template <> Stack<int> operator-<int>(const Stack<int>& a, const Stack<int>& b) { Stack<int> ret_Stack_s(a.capacity); Stack<int> ret_Stack(a.capacity); Stack<int> *n_Stack; Stack<int> a_s(a), b_s(b); while(a_s.size > 0) { ret_Stack_s.push(abs(a_s.pop() - b_s.pop())); } //sorrend megfordítása while(ret_Stack_s.size > 0) { ret_Stack.push(ret_Stack_s.pop()); } n_Stack= new Stack<int>(ret_Stack); return *n_Stack; }

elvileg jónak kéne lennie nem?
mert ugye ott van egy sima nem specializált fv., és a két fv. int-re, és double-re.
(ugye azért kellett két függvény, hogy különválasszam azt a két esetet, amikor int, és amikor double a típus, hogy az egyikre az abs(), míg másikra az fabs() legyen meghívva)

Valami ötlet?

Előre is köszi,
Amman
Mutasd a teljes hozzászólást!
Majdnem jó a megoldásod, viszont a specializált template függvények szignatúrái rosszak. Próbálkozz így:

template <> Stack<double> operator-(const Stack<double>& a, const Stack<double>& b) { // ... }
Mutasd a teljes hozzászólást!

  • Üdv!

    Szerintem az egész stacket specializálnod kéne az adott típusra.
    Lehet hogy ez hülyeség, de egy próbát megér szerintem.
    Mutasd a teljes hozzászólást!
  • Felejtsd el a specializációt!

    Valahogy így kellene:

    deklaráció:
    //abszolútértékes kivonás template <class U> friend Stack<U>& operator-(const Stack<U>&, const Stack<U>&); // abszolutertek: template <class U> friend U myAbs(const U& x);

    implementáció:
    //abszolútértékes kivonás template <class U> Stack<U>& operator-(const Stack<U>& a, const Stack<U>& b) { Stack<U> ret_Stack_s(a.capacity); Stack<U> ret_Stack(a.capacity); Stack<U> *n_Stack; Stack<U> a_s(a), b_s(b); while (a_s.size > 0) { ret_Stack_s.push(myAbs(a_s.pop() - b_s.pop())); } //sorrend megfordítása while (ret_Stack_s.size > 0) { ret_Stack.push(ret_Stack_s.pop()); } n_Stack= new Stack<U>(ret_Stack); return *n_Stack; } // függvénysablon az abszolútérték kiszámítására: template <class U> U myAbs(const U& x) { return (x >= 0) ? x : -x; }
    Mutasd a teljes hozzászólást!
  • Majdnem jó a megoldásod, viszont a specializált template függvények szignatúrái rosszak. Próbálkozz így:

    template <> Stack<double> operator-(const Stack<double>& a, const Stack<double>& b) { // ... }
    Mutasd a teljes hozzászólást!
  • Igen, így működött :)

    pelz: a te ötleted sem rossz, én is gondolkodtam, ilyenen, csak kicsit túlbonyolítva (?: operátort használtam az abs() || fabs() helyett, csak ugye a specializált függvényekben, ezért nem volt jó :)

    Köszi mindkettőtöknek!

    Üdv,
    Amman
    Mutasd a teljes hozzászólást!
Tetszett amit olvastál? Szeretnél a jövőben is értesülni a hasonló érdekességekről?
abcd