Template zlobi – C / C++ – Fórum – Programujte.com
 x   TIP: Přetáhni ikonu na hlavní panel pro připnutí webu
Reklama
Reklama

Template zlobi – C / C++ – Fórum – Programujte.comTemplate zlobi – C / C++ – Fórum – Programujte.com

 

Hledá se programátor! Plat 1 800 € + bonusy (firma Boxmol.com)
koudis
~ Anonymní uživatel
145 příspěvků
24. 4. 2010   #1
-
0
-

ahoj,
mama sablonu tridy, trida ma pratelskou fci friend EArray<T> operator+<>(EArray<T>&, EArray<T>&) ...
kdyz to chci ykompilovat tak mi to napise
EArray.cpp:213: error: declaration of ‘operator+’ as non-function
EArray.cpp:213: error: expected ‘;’ before ‘<’ token

nevite co to sakra je ?? m2lo by to fungovat normalne ale nefunguje. Je tam nekde chybka kterou nemuzu najit.
prosim pomooooocccc ... diky opravdu moc.
prikladam zdrojak (jeste neni dops takze je v nem celkem binec :))

#include <iostream>

using namespace std;


// class for exception
class Unknown
{
public:
Unknown() {};
~Unknown(){};
void PrintError()
{
cout << "Unknown ERROR in class EArray. Called invalid class!";
cout << "Can not continue !" << endl;
}
};

class Size
{ public:
Size(int* sizeofallocation,int* maxallocation)
{
eSSizeOfAllocation = sizeofallocation;
eSMaxAllocation = maxallocation;
}
~Size()
{
}
void PrintValue()
{
cout << "SizeOfAllocation: " << *(this->eSSizeOfAllocation) << endl;
cout << "MaxAllacation: " << *(this->eSMaxAllocation) << endl;
cout << endl;
}
void PrintError()
{
cout << "ERROR size in class EArray: " << endl;
PrintValue();
}
private: // S => Size, e => extension
int* eSSizeOfAllocation; // size Of Allocation .......
int* eSMaxAllocation; // MaxAllocation
};

class Zero: public Size
{
public:
Zero(int* sizeofallocation,int* maxallocation):
Size(sizeofallocation, maxallocation)
{
}
~Zero()
{
}
void PrintError()
{
cout << "ERROR size(Zero) in class EArray: value of SizeOfAllocation is zero" << endl;
PrintValue();
}
};

class Minus: public Size
{
public:
Minus(int* sizeofallocation,int* maxallocation):
Size(sizeofallocation, maxallocation)
{
}
~Minus(){}
void PrintError()
{
cout << "ERROR size(Minus) in class EArray. Some of the values is less than zero" << endl;
PrintValue();
}


};

class Plus: public Size
{
public:
Plus(int* sizeofallocation, int* maxallocation):
Size(sizeofallocation, maxallocation)
{
}
~Plus(){}
void PrintError()
{
cout << "ERROR size(Plus) in class EArray. SizeOfAllocation is bigger than MaxAllocation ()" << endl;
PrintValue();
}
};

class Index: public Size
{
public:
Index(int* sizeofallocation, int* maxallocation, int* index):
Size(sizeofallocation, maxallocation)
{
eSIndex = index;
}
~Index()
{
}
void PrintError()
{
cout << "ERROR size(Index) in class EArray." << endl;
PrintValue();
cout << "Index: " << *(this->eSIndex) << endl;
}

int* eSIndex;
};

class NotIdentical
{
public:
NotIdentical(int* sizeofallocation, int* maxallocation)
{
eNSizeOfAllocation = sizeofallocation;
eNMaxAllocation = maxallocation;
}
~NotIdentical() {}
void PrintValue()
{
cout << "SizeOfAllocation:" << *eNSizeOfAllocation << endl;
cout << "MaxAllocation: " << *eNMaxAllocation << endl;
cout << endl;
}
void PrintError()
{
cout << "Acces to NotIdentical classes" << endl;
PrintValue();
}

int* eNSizeOfAllocation;
int* eNMaxAllocation;
};


// X - operator * --> multiplication
class NotIdenticalX : public NotIdentical
{
public:
NotIdenticalX(int* sizeofallocation, int* maxallocation):
NotIdentical(sizeofallocation, maxallocation)
{
}
~NotIdenticalX() {}
void PrintError()
{
cout << "Error in multiplication !!" << endl;
PrintValue();
}

};

// M - operator (-) --> Minus
class NotIdenticalM: public NotIdentical
{
public:
NotIdenticalM(int* sizeofallocation, int* maxallocation):
NotIdentical(sizeofallocation, maxallocation)
{
}
~NotIdenticalM() {}
void PrintError()
{
cout << "Error in 'Minus' !!!" << endl;
PrintValue();
}
};

// ******start class definiton *********

template <class T>
class EArray
{

public:
EArray(int sizeofallocation, int maxallocation);
EArray(const EArray& orig);
EArray(T &); // Converts T to object EArray
virtual ~EArray();

void SetSizeOfAllocation(int sizeofallocation) { SizeOfAllocation = sizeofallocation;}
void SetMaxAllocation(int maxallocation) { MaxAllocation = maxallocation;}

int GetSizeOfAllocation() const { return SizeOfAllocation;}
int GetMaxAllocation() const { return MaxAllocation;}


T& operator[](int);
T operator[](int) const;
void operator+=(const EArray &); // EArray = EArray
EArray& operator+(const EArray &); //
EArray& operator+(T &);
EArray& operator=(const EArray &);
EArray& operator=(T &);
EArray& operator*(const EArray &);
EArray& operator-(const EArray &);

friend EArray<T>& operator+<> (const EArray<T>& left, const EArray<T>& right);
private:
EArray(int sizeofallocation, int maxallocation, int usedallocation);
EArray();
void CheckError(int index); // Check error, if necessary, throw an exception
T GetDefaultValue();
bool CheckUsedIndex(int&);

int SizeOfAllocation; // size of array allocation
int MaxAllocation; // max size of array
T* NewArray; // array :)

bool Error; // Error :)


static const int DEFAULT_MALLOC = 0; // default mAx Allocation (0 = unlimited)
static const int DEFAULT_SOA = 5; //default Size Of Allocation
static const short int DEFAULT_MINUS = -2;

};





template <class T>
EArray<T>::EArray(const EArray& orig)
{
CheckError();
EArray * help = new EArray(this->UsedAllocation);
int i;
for(i = 0; i < this->UsedAllocation; i++)
{
*(help)[i] = orig[i];
}
} // end function


template <class T>
EArray<T>::EArray():
SizeOfAllocation(DEFAULT_SOA),
MaxAllocation(DEFAULT_MALLOC),
Error(false)
{ // CheckError() is unnecessary to do
NewArray = new T[this->SizeOfAllocation];
int i;
for(i = 0; i < 0; i++)
{
NewArray[i] = GetDefaultValue();
}
} // end function



template <class T>
EArray<T>::EArray(int sizeofallocation,int maxallocation):
Error(false) // other definition in next line :)
{
this->SizeOfAllocation = sizeofallocation;
this->MaxAllocation = maxallocation;
NewArray = new T[this->SizeOfAllocation];

int i;
for(i = 0; i < this->SizeOfAllocation; i++)
{
NewArray[i] = GetDefaultValue();
}
CheckError(DEFAULT_MINUS);

} // end function


template <class T>
EArray<T>::EArray(int sizeofallocation, int maxallocation, int usedallocation):
SizeOfAllocation(sizeofallocation),
MaxAllocation(maxallocation),
Error(false)
{
CheckError(DEFAULT_MINUS);
NewArray = new T[this->SizeOfAllocation];
} // end function



template <class T>
EArray<T>::EArray(T& value):
Error(false)
{
EArray<T>* helpobject = new EArray<T>(1,1,1);
helpobject[0] = value;
*helpobject;
} // end function


template <class T>
void EArray<T>::CheckError( int index)
{
if(this->Error == true)
{
throw Unknown();
}

if( this->SizeOfAllocation < 0 || this->MaxAllocation < 0)
{
this->Error = true;
cout << "minuuusss" << endl;
throw Minus(&SizeOfAllocation, &MaxAllocation);
}
if(this->MaxAllocation != 0)
{
if( (this->SizeOfAllocation - this->MaxAllocation) > 0 )
{
this->Error = true;
cout << "Plus" << endl;
throw Plus(&SizeOfAllocation, &MaxAllocation);
}

if( this->SizeOfAllocation > this->MaxAllocation)
{
this->Error = true;
cout << "index1" << endl;
throw Index(&SizeOfAllocation, &MaxAllocation, &index);
}
if( (index + 1) > this->MaxAllocation)
{
this->Error = true;
cout << "index2" << endl;
throw Index(&SizeOfAllocation, &MaxAllocation, &index);
}
}
} // end function




template <class T>
EArray<T>::~EArray()
{
delete[] this->NewArray;
} // endfunction


template <class T>
T EArray<T>::GetDefaultValue()
{
return (T)0;
}


template <class T>
bool EArray<T>::CheckUsedIndex(int& index)
{
if(NewArray[index] == GetDefaultValue())
{
return false;
} else {
return true;
}
} //end function

// OVERLAP OPERATORS ****************************************


template <class T>
T EArray<T>::operator[](int index) const
{
if( index >= this->SizeOfAllocation)
{
return NewArray[this->SizeOfAllocation - 1];
} else {
return NewArray[index];
}
} // end function


template <class T>
T& EArray<T>::operator[](int index) // EArray[index] = T
{
CheckError(index);
if(index >= this->SizeOfAllocation)
{
int helpsize = 0;
if((this->SizeOfAllocation - this->MaxAllocation) < (DEFAULT_SOA) && this->MaxAllocation != 0)
{
helpsize = this->MaxAllocation - this->SizeOfAllocation;
} else {
helpsize = DEFAULT_SOA;
}
T * helparray = new T[this->SizeOfAllocation + helpsize];

int i;
for(i = 0; i < (this->SizeOfAllocation + helpsize); i++)
{
if( i < this->SizeOfAllocation)
{
helparray[i] = NewArray[i];
}
if( i >= helpsize)
{
helparray[i] = GetDefaultValue();
}
}
delete[] NewArray;
NewArray = helparray;
this->SizeOfAllocation = index + 1;
return NewArray[index];

} else if(index < this->SizeOfAllocation)
{
return NewArray[index]; //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!§§§
}
} // end function



template <class T>
EArray<T> & EArray<T>::operator=(const EArray & right)
{
CheckError(DEFAULT_MINUS);
this->MaxAllocation = right.GetMaxAllocation();
this->SizeOfAllocation = right.GetSizeOfAllocation();
int i;
for(i = 0; i < right.SizeOfAllocation; i++)
{
NewArray[i] = right[i];
}
return *this;
} // end function


template <class T>
EArray<T>& EArray<T>::operator=(T& right)
{
CheckError(DEFAULT_MINUS);
this->MaxAllocation = right.GetMaxAllocation();
this->SizeOfAllocation = right.GetSizeOfAllocation();
} // end funcion


template <class T>
EArray<T> & EArray<T>::operator+(const EArray & right) // EArray + (EArray)right
{
CheckError(DEFAULT_MINUS);
int helpSizeOfAllocation = this->SizeOfAllocation + right.GetSizeOfAllocation();
int helpMaxAllocation = this->MaxAllocation + right.GetSizeOfAllocation();
EArray<T>* helpobject = new EArray(helpSizeOfAllocation, helpMaxAllocation);
int i;
for(i = 0; i < helpSizeOfAllocation; i++)
{
if( i <= helpSizeOfAllocation)
{
helpobject[i] = NewArray[i];
}
if( i > helpSizeOfAllocation)
{
helpobject[i] = right[i];
}
}
return helpobject;
} // end function



template <class T>
EArray<T>& EArray<T>::operator+(T& right) // EArray + (T)right;
{
CheckError(DEFAULT_MINUS);
EArray<T>* helpobject = new EArray<T>(this->SizeOfAllocation, this->MaxAllocation);

int i;
for(i = 0; i < this->SizeOfAllocation; i++)
{
(*helpobject)[i] = NewArray[i];
}
return *helpobject;
} // end function;



template <class T>
void EArray<T>::operator+=(const EArray& right) // EArray += (EArray)right
{
CheckError(DEFAULT_MINUS);
if(right.GetMaxAllocation() == 0)
{
this->MaxAllocation = 0;
} else {
this->MaxAllocation += right.GetMaxAllocation(); // help Total Used Alocacion ...
}
this->SizeOfAllocation += right.GetSizeOfAllocation();
T* helparray = new T[this->SizeOfAllocation + right.GetSizeOfAllocation()];
int i;
for(i = 0; i < (this->SizeOfAllocation + right.GetSizeOfAllocation()); i++)
{
if(i < this->SizeOfAllocation)
{
helparray[i] = NewArray[i];
}
if(i >= this->SizeOfAllocation)
{
helparray[i] = right[i];
}
}
delete[] NewArray;
NewArray = helparray;
} // end function



template <class T>
EArray<T>& EArray<T>::operator*(const EArray& right) // EArray = EArray*(EArray)right;
{
CheckError(DEFAULT_MINUS);
if(SizeOfAllocation = right.GetSizeOfAllocation())
{
EArray* helpobject = new EArray(this->SizeOfAllocation, right.GetMaxAllocation());
int i;
for(i = 0; i < this->SizeOfAllocation; i++)
{
(*helpobject)[i] = NewArray[i]*right[i];
}
return *helpobject;
} else {
this->Error = true;
throw NotIdenticalX(this->SizeOFAllocation, this->MaxAllocation);
}
} // end function



template <class T>
EArray<T>& EArray<T>::operator-(const EArray& right) // EArray = EArray - (EArray)right
{
CheckError(DEFAULT_MINUS);
if(this->SizeOfAllocation == right.GetSizeOfAllocation())
{
EArray<T>* helpobject = new EArray<T>(this->SizeOfAllocation, this->MaxAllocation);
int i;
for(i = 0; i < this->SizeOfAllocation; i++)
{

(*helpobject)[i] = NewArray[i] - right[i];
}
return *helpobject;
} else {
this->Error = true;
throw NotIdenticalM(&(this->SizeOfAllocation), &(this->MaxAllocation));
}
} // end function

/**********************************************************************************************************************************/
/************** friend FUNCTIONS***************************************************************************************************/
/***********************************************************************************************************************************/

template <class T>
EArray<T>& operator+(const EArray<T>& left, const EArray<T>& right)
{
EArray<T>* helpobject = new EArray<T>(left.GetSizeOfAllocation(),
right.GetMaxAllocation());
*helpobject = left + right;
return *helpobject;
}

/*
template <class T>
EArray<T>& operator-
*/
int main()
{
int h = 5;
EArray<int> help(10, 0);
EArray<int> help2(10, 0);
EArray<int>* help3 = new EArray<int>(10, 56);
help[0] = h;
help2[0] = h;
(*help3)[2] = 56;
cout << "help, SizeOfAllocation: " << help.GetSizeOfAllocation() << endl;
cout << "help2, Sizeofall : " << help2.GetSizeOfAllocation() << endl;
help2 += help;
*help3 = help - help2;
cout << "constrol pocet :" << help2.GetSizeOfAllocation() << endl;
cout << endl << (*help3)[0] << endl;
*help3 = help2 + h;
cin >> h;
}

Nahlásit jako SPAM
IP: 85.92.39.–
Reklama
Reklama
Quiark0
Věrný člen
24. 4. 2010   #2
-
0
-

A zkoušel jsi to bez toho <> za operator+ ? Jen tipuju...

Nahlásit jako SPAM
IP: 90.178.173.–
koudis
~ Anonymní uživatel
145 příspěvků
24. 4. 2010   #3
-
0
-

jasne, zkousel, ale napisemi to, ze to tam ma dat ... kdyz to tam dam, tak mi to hodi chybu ... asi nejaky bug nebo co :)

Nahlásit jako SPAM
IP: 85.92.39.–
Wizard0
Stálý člen
24. 4. 2010   #4
-
0
-

Skusal si to nejako takto:



friend template<class T> EArray<T>& EArray<T>::operator+ (const EArray<T>& left, const EArray<T>& right);

Nahlásit jako SPAM
IP: 85.216.193.–
koudis
~ Anonymní uživatel
145 příspěvků
24. 4. 2010   #5
-
0
-

zkoušel,
ja tu fci mám mimo třídu ne v třídě ... takže jsem to zkouel bez EArray<T>operator+ , ani s tim to bohu6el nefunguje :)

Nahlásit jako SPAM
IP: 85.92.39.–
koudis
~ Anonymní uživatel
145 příspěvků
24. 4. 2010   #6
-
0
-

To koudis : možná jsem odpovedel trosku nejednoznacne .. zkoušel jsem to i timto zpusobem .. lae nefunguje ...

Nahlásit jako SPAM
IP: 85.92.39.–
Wizard0
Stálý člen
25. 4. 2010   #7
-
0
-

no tak ked je mimo triedy tak bez EArray<T>::

Nahlásit jako SPAM
IP: 85.216.193.–
Jura
~ Anonymní uživatel
634 příspěvků
25. 4. 2010   #8
-
0
-

Zdravím,

kód jsem proletěl jen letmo, deklarace přátelských operátorů je ok(skutečně se píše operator+ <>(....)), nicméně co ti tam nejspíše chybí je dopředná deklarace těch přátelských funkcí. Zkus to podobne jako v tomto příkladě:



#include <iostream>

/////////////////////////////////////////////
// dopredne deklarace

template<typename T>
class MyClass;

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

template<typename T>
std::ostream& operator<<(std::ostream& os, const MyClass<T>& );

/////////////////////////////////////////////
// definice

template<typename T>
class MyClass
{
public:
// typy
typedef T value_type;
friend MyClass operator+<>(const MyClass<T>&, const MyClass<T>& );
friend std::ostream& operator<< <>(std::ostream& os, const MyClass<T>& );

public:
// konstrukce / destrukce
MyClass()
{}

explicit MyClass(const value_type& value)
: value_(value)
{}

private:
// implementace
MyClass<T> DoSum(const MyClass<T>& other) const
{
// logika kopirovani
return MyClass<T>(value_ + other.value_);
}

private:
// atributy
value_type value_;
};

template<typename T>
MyClass<T> operator+(const MyClass<T>& a, const MyClass<T>& b)
{
return a.DoSum(b);
}

template<typename T>
std::ostream& operator<<(std::ostream& os, const MyClass<T>& arg)
{
return os << arg.value_;
}

int main()
{
MyClass<int> a(5), b(3), c;
c = a + b;
std::cout << c << std::endl;
return 0;
}


Jinak příště se snaž ten zdroják zkrátit na minimální problémovou část, pak by se v tom snad dalo lépe hledat a jaký kompilátor používaš.

Nahlásit jako SPAM
IP: 85.207.192.–
koudis
~ Anonymní uživatel
145 příspěvků
25. 4. 2010   #9
-
0
-

To Jura :
jasně,díky
používám g++, když jsem to přepsal podle navodu víše, tak mi tozase začalo psát "undefined reference" ... už jsem z toho na větvi, všechny funkce mám deklarované, nikde chyba v opisu a přesto to píše undefined reference :) ...

Nahlásit jako SPAM
IP: 85.92.39.–
liborb
~ Redaktor
+18
Guru
26. 4. 2010   #10
-
0
-

Koukám na to tvoje čiré zoufalství ... zkusil jsem to v MVS (když už si sem dal celý kód) a opravdu stačilo vyhodit <> (a opravit drobnost u operátoru []) a všechno šlape jak hodinky.

Nahlásit jako SPAM
IP: 85.207.166.–
koudis
~ Anonymní uživatel
145 příspěvků
26. 4. 2010   #11
-
0
-

To liborb :
smím-li se yeptat ... jaka drobnost u operator[] ??

Nahlásit jako SPAM
IP: 85.92.39.–
liborb
~ Redaktor
+18
Guru
26. 4. 2010   #12
-
0
-

Drobnost ... jak je to strašně chytrý :smile1: , tak se mu nelíbila formulace:



if (a > 0) {
}
else if (a <= 0) {
}


protože tam stačí:


if (a > 0) {
}
else {
}

Nahlásit jako SPAM
IP: 85.207.166.–
koudis
~ Anonymní uživatel
145 příspěvků
26. 4. 2010   #13
-
0
-

prosim jeste pomoct :) ...díky předem moct (hodím sem celí zdroják, nevím co mám vyhodit a co nechat, dám ho do sam souboru :))
vygooglil jsem řádek 223, kdž ho takhle implementuji, zmizí hláška "undefined reference" ale objeví se hláška "|624|error: no match for 'operator+' in 'h2 + help3'|" ... vubec nevím kde mám chzbu, jsem už z toho troěšku natzvrdlý :) ...
opravdu dík moc za rady :) ...
(friend operator je až na konci souboru ...)

Nahlásit jako SPAM
IP: 85.92.39.–
ondra.holub
~ Anonymní uživatel
253 příspěvků
26. 4. 2010   #14
-
0
-

Úplně na konci je help = h2 + help3; Ale nikde není definován operátor+, který má na levé straně int a na druhé EArray.

Nahlásit jako SPAM
IP: 194.138.12.–
koudis
~ Anonymní uživatel
145 příspěvků
26. 4. 2010   #15
-
0
-

To ondra.holub :
ale je tam konstruktor, který přijímá int parametr, kompilátor by měl tímto konstruktorem předělat h2 na objekt EArray, a pak zavolat friend operator+(EArray, EArray) ... v prikladech na internetu to tak funguje, a i me to tak funguje. Nekde tam je chyba, mazbna ta ped deklarace pred def. tridy ....

Nahlásit jako SPAM
IP: 85.92.39.–
koudis
~ Anonymní uživatel
145 příspěvků
26. 4. 2010   #16
-
0
-

kdyz odstranim z 223 ty :: a <> .tak to zacne hlasit zase "undefined reference"

Nahlásit jako SPAM
IP: 85.92.39.–
Zjistit počet nových příspěvků

Přidej příspěvek

Toto téma je starší jak čtvrt roku – přidej svůj příspěvek jen tehdy, máš-li k tématu opravdu co říct!

Ano, opravdu chci reagovat → zobrazí formulář pro přidání příspěvku

×Vložení zdrojáku

×Vložení obrázku

Vložit URL obrázku Vybrat obrázek na disku
Vlož URL adresu obrázku:
Klikni a vyber obrázek z počítače:

×Vložení videa

Aktuálně jsou podporována videa ze serverů YouTube, Vimeo a Dailymotion.
×
 
Podporujeme Gravatara.
Zadej URL adresu Avatara (40 x 40 px) nebo emailovou adresu pro použití Gravatara.
Email nikam neukládáme, po získání Gravatara je zahozen.
-
Pravidla pro psaní příspěvků, používej diakritiku. ENTER pro nový odstavec, SHIFT + ENTER pro nový řádek.
Sledovat nové příspěvky (pouze pro přihlášené)
Sleduj vlákno a v případě přidání nového příspěvku o tom budeš vědět mezi prvními.
Reaguješ na příspěvek:

Uživatelé prohlížející si toto vlákno

Uživatelé on-line: 0 registrovaných, 84 hostů

Podobná vlákna

If nevim proc me zlobi — založil Hlavinka

DataGridView opět zlobí — založil Miromancer

Visual Studio zlobí... — založil Laik

Moderátoři diskuze

 

Hostujeme u Českého hostingu       ISSN 1801-1586       ⇡ Nahoru Webtea.cz logo © 20032016 Programujte.com
Zasadilo a pěstuje Webtea.cz, šéfredaktor Lukáš Churý