Przeciążanie + operator z szablonami

Question

Hej, pojawia się błąd łącznika LNK2019: nierozwiązany symbol zewnętrzny podczas próby użycia przeciążonego operatora +. Pokażę ci wycinek z klasy i sposób, w jaki go używam. Jeśli chcesz zobaczyć więcej, daj mi znać, po prostu postaram się zachować zwięzłość.

/** vec.h **/ 
#ifndef __VEC_H_ 
#define __VEC_H_ 

#include <iostream> 
#include <vector> 

namespace xoor{ 

    template<typename T> 
    class vec{ 

    public: 
     inline friend vec<T> operator + (const vec<T>&, const vec<T>&); 
     inline const vec<T>& operator += (const vec<T>&); 

    private: 
     std::vector<T> m_index; 
    }; // Vec. 


    template<typename T> 
    vec<T>& operator + (const vec<T>& a, const vec<T>& b){ 
     vec<T> product = a; 
     product += b; 

     return product; 
    } // Addition. 

    template<typename T> 
    const vec<T>& vec<T>::operator += (const vec<T>& v){ 
     for (unsigned short i =0; i < m_index.size(); ++i){ 
      if (i >= v.size()) 
       break; 
      m_index[i] += v.getIndex()[i]; 
     } 

     return * this; 
    } // Addition Compound. 


} // xoor 

#endif // __VEC_H_ 

Zwróć uwagę, że mam również [] przeciążone, dlatego właśnie uzyskuję dostęp do części m_indexu. getIndex() po prostu zwraca m_index. I wielkość() zwraca m_index.size()

/** main.cpp **/ 

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

void testHook(); 

int main(){ 
    testHook(); 
    system("PAUSE"); 
    return 0; 
} 

void testHook(){ 
    using namespace xoor; 
    vec<double> vA(3); // passing 3 for 3 elements 
    vec<double> vB(3); 

    // v + v 
    std::cout << "\n\tA + B = "; 
    vec<double> vAB(3); 
    vAB = vA + vB; // PRODUCES THE LNK2019 
    vAB.print(std::cout); // Outputs the vec class to the console. 
} 

komunikat o błędzie:

Error 1 error LNK2019: unresolved external symbol "class xoor::vec<double> __cdecl xoor::operator+(class xoor::vec<double> const &,class xoor::vec<double> const &)" (??Hxoor@@YA?AV?$vec@N@0@ABV10@0@Z) referenced in function "void __cdecl testHook(void)" (?testHook@@YAXXZ) main.obj 

Aktualizacja:

Poniżej znajduje się bezpośrednio powyżej definicji klasy. Wciąż mam ten sam błąd linkera, jak opisano powyżej.

template<typename T> 
    class vec; 

    template<typename T> 
    vec<T> operator + (const vec<T>&, const vec<T>&); 

---

Aktualizacja 2: Rozwiązanie.

Powyższa aktualizacja jest niepoprawna. Rozwiązanie sbi działało, po prostu nie udało mi się dopasować operatora w następujący sposób.

template<typename T> 
    vec<T> operator +<T> (const vec<T>&, const vec<T>&); 

sbi i David zastanawiali się, dlaczego używam przyjaciół w pierwszej kolejności. Początkowo używałem ich, ponieważ nie można przekazać dwóch parametrów do przeciążonego operatora binarnego, takiego jak +, i natychmiast poszukiwano przyjaciół jako rozwiązania. Jak się okazuje, nadal można z łatwością używać operatora binarnego za pomocą jednego parametru. Oto ostateczne rozwiązanie.

// ... 
template<typename T> 
class vec{ 
    public: 
    const vec<T> operator + (const vec<T>&, const vec<T>&)const; 
    // ... 

}; // Vec. 

template<typename T> 
const vec<T> vec<T>::operator + (const vec<T>& v)const{ 
    matrix<T> product = *this; 
    vec(product += v); 
} // Addition. 

Ponadto, dla każdego, kto to czyta, warto sprawdzić jego notatki na dole odpowiedzi. Są pewne rzeczy, które robiłem, które są zbędne.

Dzięki za pomoc dla wszystkich. Szczęśliwe kodowanie.

Answer 1

Aby zaprzyjaźnić się szablon, myślę, że trzeba zadeklarować tego szablonu przed definicja klasy, w której chcesz się zaprzyjaźnić. Jednakże, aby ta deklaracja została skompilowana, musisz przekazać dalej - zadeklaruj szablon klasy. Tak to powinno działać:

template<typename T> 
class vec; 

template<typename T> 
vec<T> operator + (vec<T>, const vec<T>&); 

template<typename T> 
class vec{ 
public: 
    friend vec<T> operator +<T> (vec<T>, const vec<T>&); 
// ... 

Ten zaprzyjaźnia konkretną instancję szablonu operator+() funkcję, a mianowicie operator+<T>. (Możesz też zaprzyjaźnić się ze wszystkimi wystąpieniami szablonu:

// no forward declarations necessary 

template<typename T> 
class some_class { 
    template<typename U> 
    friend void f(vec<U>&); 
    // ... 
}; 

Jest to jednak mniej przydatne niż inne.)

Edit: Komentarz przez Dawida dało mi do myślenia (powinno zrobiłem to od początku) i które prowadzą do odkrycia, że ​​deklaracja friend jest niepotrzebna!. Twój operator+ używa tylko jednej funkcji składowej public z vec (operator+=) i dlatego nie musi być klasą friend. Więc powyższe byłoby uprościć do

template<typename T> 
class vec{ 
public: 
    // ... 
}; 

template<typename T> 
vec<T> operator + (vec<T> a, const vec<T>& b){ 
    a += b; 
    return a; 
} 

---

Oto jeszcze kilka uwag:

• operator+() (które ładnie realizowane na szczycie operator+=(), BTW) powinny brać swój lewy argument za kopii.
• nie Czy deklarują funkcje inline, określić je tak.
• Otrzymano operator+=() zwracając odwołanie inne niż const, ponieważ każdy oczekuje, że f(m1+=m2) zadziała, nawet jeśli f() przyjmuje swój argument jako odniesienie inne niż const.
• Wewnątrz szablonu klasy, w większości miejsc można pominąć listę parametrów szablonu, odwołując się do klasy. Możesz więc powiedzieć: vec& operator += (const vec&);. (Nie można zrobić poza szablonem, choć - na przykład przy definiowaniu tego przedsiębiorcę poza klasą.)
• std::vector „s typ indeksu orkisz std::vector<blah>::size_type, nieunsigned short.

Answer 2

Typ zwracany tutaj:

inline friend vec<T> operator + (const vec<T>&, const vec<T>&); 

nie pasuje tutaj:

template<typename T> 
    vec<T>& operator + (const vec<T>& a, const vec<T>& b){ 
     vec<T> product = a; 
     product += b; 

     return product; 
    } // Addition.