Sablona - bin. operatory – C / C++ – Fórum – Programujte.com

Hey, dalsi vcelku zajimavej dotazek:

mam sablonu tridy, ktera muze vytvaret objekty typu napr. int nebo double. A ted si v te sablone pretizim operator+ (binarni) tak, ze vysledek vzdy ukladam do nove vytvoreneho objektu. No a jak ten operator pozna jakeho typu ma byt vysledek, kdyz scitam treba objekt int s objektem double? Takhle bez prikladu je to tezke vysvetlit, ale to bych sem musel nakopirovat tak 100 radek kodu ;-)

Asi nejlepší bude když sem hodíš ten svůj zdrojový kód, nebo alespoň část kódu jak by podle tebe mělo to přetížení operátoru vypadat. Z toho popisu sem to moc nepochopil.

ok, hazim sem cely kod, omlouvam se tem, kterym to vadi :) takhle jak to je, tak to jde zkompilovat, ale kdyz chci ten operator scitani pouzit v main, tak to zacne kricet prave cosi o tech ruznych typech. Jeste chci pretizit dalsi binarni operatory, takze ten problem je pro me dost klicovej. Jo, mam tam trochu bordel v tom, ze neco jsem nadefinoval hned v te sablone, neco az zvlast, ale na funkcnost to snad nema vliv.

#include <iostream>

#include <cstdlib>

using namespace std;





template <class Type, int N=2>

class Vector 

{

      Type * array;

      int size, maxSize;



    public:

      Vector();

      Vector(int n);      

      Vector(const Vector & v);

      virtual ~Vector();



      Type & operator [](int i);

      friend ostream& operator<<(ostream& o, Vector& v) {

		  o << "(";

		  for (int i = 0; i < v.length(); i++) {

                      o << v[i];

                      if (i < v.length() - 1) o << ",";

                  }

                  o << ")"<< endl;

                  return o;

      }



      Vector & operator=(const Vector & v);

      Vector & operator+(const Vector<Type, N>& v) {

		  if (v.size!=size) {									

		     cerr << "error vector::operator+, can't add vectors of different size" << endl;

		     exit(1);												

	          }

	          Vector<Type, N> temp;

		  for(int i=0;i<size;i++) temp.array[i]=array[i]+v.array[i]; 	

	          return temp;											

      }

      int length() const;

};



////////////////////////////////////

//----------DEFINICE----------//

////////////////////////////////////



   template <class Type, int N>

   Vector<Type, N>::Vector() {

          maxSize=N;

	  array = new Type[maxSize];

	  for(int i=0;i<N;i++) array[i]=0;

	  size=N;

   }

 

   template <class Type, int N>

   Vector<Type, N>::Vector(int n) {

	  maxSize=N;

          if (N < 0) {

            cerr << "error -- creating a Vector of negative capcity\n";

            exit(1);

          }

	  for(int i=0;i<N;i++) array[i]=n;

	  size=N;

   }



   

   template <class Type, int N>

   Vector<Type, N>::Vector(const Vector & v) {

      if (this == &v) {

            cerr << "error -- cannot copy a vector to itself\n";

            exit(1);

      }

      array = 0;

      array = new Type[v.maxSize];

      size = v.length( );

      maxSize = v.maxSize;

      for (int i = 0; i < v.length( ); i++) {

      array[i] = v.array[i];

      }

   }



   

   template <class Type, int N>

   Vector<Type, N>::~Vector() {

      delete [] array;

   }



 

   template <class Type, int N>

   Type & Vector<Type, N>::operator [] (int i) {

      if (i < 0 || i >= size) {

             cerr << "error -- index out of range\n";

             exit(1);

      }

      return array[i];

   }

   

   template <class Type, int N>

   Vector<Type, N> & Vector<Type, N>::operator=(const Vector & rhs) {

      if (this == &rhs) {

            cerr << "error -- cannot assign a vector to itself\n";

            exit(1);

      }

      delete [] array;

      size = rhs.length( );

      maxSize = rhs.maxSize;

      array = new Type[maxSize];

      for (int i = 0; i < size; i++)

      array[i] = rhs.array[i];

      return *this;

   }



   template <class Type, int N>

   int Vector<Type, N>::length() const {

   return size;

   }





//////////////////////////////

//-----------MAIN-----------//

//////////////////////////////



int main(int argc, char *argv[])

{

	Vector<double, 3> b;

	b[0]=0.6;

	b[1]=1.4;

	b[2]=5.1;

	cout << b;

	Vector<int, 3> c;

	c[0]=4.7;

	c[1]=1.1;

	c[2]=7.1;

	cout << c;

	//a ted bych tu chtel neco jako d=b+c;

	system("PAUSE");

	return EXIT_SUCCESS;

}

No buď můžeš definovat 2 metody s přetíženým oparátorem každou pro jiný typ (explicitní specializace):

Vector<int, N> operator+(const Vector<int, N>& v)

Vector<double, N> operator+(const Vector<double, N>& v)

template <typename Type2>

 Vector<Type2, N> & operator+(const Vector<Type2, N>& v)

Vector operator+(const Vector<Type, N>& v) {

              if (v.size!=size) {                                                      

                 cerr << "error vector::operator+, can't add vectors of different size" << endl;

                 exit(1);                                                                        

                }

                Vector<Type, N> temp;



              for(int i=0;i<size;i++) 

                 temp.array[i]=array[i]+v.array[i];       

                return temp;                                                                  

      }

To Gadael : odkdy je operator scitani binarni? to ze mu predavas pouze jeden parametr neznamena ze je binarni, pouze to znamena ze prvni parametr je automaticky instance daneho typu ke ktere pristupujes pomoci this (pokud operator deklarujes jako clen tridy, pokud ho deklarujes jako globalniho frienda tak ma parametry 2).
zkus to pres virtualni funkce, tedy odvod si tridy pro vsechny typy ktery chces pouzivat od nejakyho abstraktniho predka, a nadefinuj jim stejnej pristup k datum. pak jen u predka pretizis operatory a je to.

EDIT by tmi: prvni odstavec tohoto prispevku je naprosty zvast, je videt ze jsem ho psal v jednu v noci, mirne opily. problem spociva v tom ze jsem si spletl slova binarni a unarni. vsem se omlouvam za svou neprekonatelnou tupost.

Myslím, že Gadael chtěl slovem binární říci, že přijímá 2 operandy a že tedy není unární+.
Jinak myslím, že to, co tady zmínil Johnyzz by mělo fungovat.

// Takto bude vypadat hlavička té členské fce:

template <typename Type, int N> // Šablona třídy.

template <typename Type2> // Šablona funkce (specifikuje typ parametru, jeho délka musí být stejná jako u prvního parametru.

Vector<Type, N> // Navrací hodnotou Vektor podle šablony třídy.

Vector<Type, N>::operator+ // Název metody.

(const Vector<Type2, N>& druhy) { // Druhý parametr za this. 		

// Ještě třeba dodat, že musí existovat operator+ mezi typy Type a Type2. 

To Huge : nejak se ztracim v tom, co je hlavicka ceho - jestli funkce nebo tridy.

Takze to prvni

template <typename Type, int N>

template <typename Type2>