Generikus Stack c++ fordító gondok

Generikus Stack c++ fordító gondok
2010-04-03T11:08:55+02:00
2010-04-04T22:15:40+02:00
2022-11-17T07:55:36+01:00
amman
Sziasztok!

Aki figyelemmel kísérte a generikus stack programom, annak elárulhatom, hogy készen van. :)
Most megpróbálom úgy átírni/kijavítani a kódot, hogy minél több fordító elfogadja.
Most ott tartok, hogy VS2008 warning és error nélkül fordítja, futtatja, viszont dev-cpp csak sír, sír és sír...

Header itt, main.cpp itt.

A hibák, amiket dev-cpp dob (sajnos csak egyenkét engedné kijelölni...):
Link.

Előre is köszi a segítséget!

Üdv,
Amman

UI: tudom a main.cpp lehetne szebb is, de a program írása közben készült, azért ilyen kusza :)
UI2: 1-2 függvény még át lesz írva, hogy még inkább "stackesebb" legyen, tehát hogy sehol ne lehessen elérni közvetlenül a 2., 3., 4. ... elemet.
Mutasd a teljes hozzászólást!
Egy másik
topic
-ban már leírtam (nem te nyitottad, de a tied következtében keletkezett) ...

Szerintem:
A te osztályod ugye
T
típusú, a barát függvény pedig
U
. Akárhogy nézzük ez azt jelenti, hogy elvileg a két típus nem egyezik... Az más kérdés, hogy a
VS
ennek ellenére "helyre tudja rakni".

Dióhéjban egy működő, de meglehetősen rövid példa:

template <class T> class Stack { public: Stack(void) { } Stack(const Stack&) { } ~Stack(void) { } Stack& operator =(const Stack&) { return *this; } Stack operator *(const T&) const { return Stack(); } }; template <class T> inline Stack<T> operator *(const T& t, const Stack<T>& s) { return s*t; } int main(int argc, char *argv[]) { Stack<double> s1, s2; s1 = s1 * 2.0; s2 = 3.0 * s2; return 0; }
Mutasd a teljes hozzászólást!

  • Egyre máris tudok valamit mondani. Az abs() csak int-re van. Ha double -re kell akkor fabs().

    Plusz egy kérdés amit most gyorsan kipróbáltam :D. Miért definiáltad felül az = operátort? Nekem tökéletesen megy az alap = operátorral de mondom most gyorsan megnéztem. Na az == operátort már tényleg felül kellett definiálnom .
    Mutasd a teljes hozzászólást!
  • jó hogy mondod, az abs, azzal még kell foglalkoznom (ugye a stack lehet pl int és double is, szal majd megírom hogy mikor mit használjon).
    Az =op.-ról tudtam, hogy megy, de nem feltétlen szeretek bízni az ilyen "így is megy" dolgokban, + gyakorlásnak sem utolsó :)

    A fontosabb része az talán az operator+/-/*, ezeket nem értem, miért nem fogadja el...
    Mutasd a teljes hozzászólást!

  • Plusz egy kérdés amit most gyorsan kipróbáltam :D. Miért definiáltad felül az = operátort?


    Pl azert, hogy ne masolja at a buff pointert..?
    Mutasd a teljes hozzászólást!
  • Mondjuk logikus, jó oké igazat adok .
    Mutasd a teljes hozzászólást!
  • esetleg ötlet, hogy mi lehet a többi hiba?
    Mutasd a teljes hozzászólást!
  • Egy másik
    topic
    -ban már leírtam (nem te nyitottad, de a tied következtében keletkezett) ...

    Szerintem:
    A te osztályod ugye
    T
    típusú, a barát függvény pedig
    U
    . Akárhogy nézzük ez azt jelenti, hogy elvileg a két típus nem egyezik... Az más kérdés, hogy a
    VS
    ennek ellenére "helyre tudja rakni".

    Dióhéjban egy működő, de meglehetősen rövid példa:

    template <class T> class Stack { public: Stack(void) { } Stack(const Stack&) { } ~Stack(void) { } Stack& operator =(const Stack&) { return *this; } Stack operator *(const T&) const { return Stack(); } }; template <class T> inline Stack<T> operator *(const T& t, const Stack<T>& s) { return s*t; } int main(int argc, char *argv[]) { Stack<double> s1, s2; s1 = s1 * 2.0; s2 = 3.0 * s2; return 0; }
    Mutasd a teljes hozzászólást!
  • Szerintem nem szamit a betu a template-ben...
    Mutasd a teljes hozzászólást!
  • Ha mindegyiket egyformának írod, akkor valóban mindegy, hogy milyen betűt írsz oda (szó is lehet ugye). Egyébként nem mindegy! Ha pl. osztályon belül eltérő betűket használhatnál ugyanannak a típusnak a megjelölésére, akkor mivel tudnád jelezni a fordítónak, hogy az eredetitől egy eltérő típusról van szó?
    Mutasd a teljes hozzászólást!
  • Ha pl. osztályon belül eltérő betűket használhatnál ugyanannak a típusnak a megjelölésére, akkor mivel tudnád jelezni a fordítónak, hogy az eredetitől egy eltérő típusról van szó?


    Nem erre ertettem, kulonbozo template-eknel szerintem nem kell megegyezzen a betu ahhoz, hogy kompatibilisek legyenek...

    A tegnap kiprobaltam a kodjat U-t atirva T-re, ugy sem mukodott!
    Mutasd a teljes hozzászólást!
  • Az általam megadott kód
    MSVS 2008 E
    -ben és
    MinGW (gcc 3.4.5)
    -ben is egyaránt működik.
    Mutasd a teljes hozzászólást!
  • Az altalad megadott kod valamivel egyszerubb a kerdezoenel...
    Mutasd a teljes hozzászólást!
  • egyszerubb a kerdezoenel...

    Csak a "belseje" más, egyébként meg a kérdező kódja "több sebből vérzik" - nem érzem feladatomnak, hogy azt foltozgassam...
    Mutasd a teljes hozzászólást!
  • Akkor igy modositsd a kodod, es probald forditani:


    template <class U> inline Stack<U> operator *(const U& t, const Stack<U>& s) { return s*t; }

    Mutasd a teljes hozzászólást!
  • A const hianya az operator= parameterenel a gond, ugyanis a 2.0*S1 eredmenye egy temporary ojjektum lesz, ami const, ezert nem hasznalhato a te = operatorod!

    Engem old sharky kodja vezetett ra, adhatod neki a pontot!
    Mutasd a teljes hozzászólást!
  • probald forditani


    Az egy korábbi topicban már ki lett tárgyalva, hogy nem fog menni...
    Mutasd a teljes hozzászólást!
  • Nekem 4.3.3-as g++-al ment.

    Szerk: a masik topicban a frienddel volt gond, ha jol emlekszem...
    Mutasd a teljes hozzászólást!
  • A
    template
    -ekben lévő
    template friend
    -ekkel meglepő problémák jelentkezhetnek (leginkább a régebbi fordítóknál)...
    Mutasd a teljes hozzászólást!
  • Lasd >>Itt az ujabb hsz-em!
    Mutasd a teljes hozzászólást!
  • main.cpp
    #include <iostream> #include "stack.h" using namespace std; template <class T> void insert(Stack<T>& S1, T x) { try { S1.push(x); } catch(char* p) { cout << p << endl; } } int main() { Stack<double> S1(10), S2(10); Stack<double> S3,S4,S5,S6,S7; insert(S1, 3.299); insert(S1, 4.0); insert(S1, 1.1); insert(S1, 87.9); insert(S1, 12.4); insert(S1, 34.1); insert(S1, 10.99); insert(S1, 534.999); insert(S1, 1.3445); insert(S1, 3.45); insert(S1, 0.0001); insert(S1, 33.4); S2 = S1; //cout<<(S2==S1?"egyenlo":"nem")<<endl; //stackösszeadáshoz S3 = S1; S4 = S1; ////// cout << S1.top() << endl; try{ S1.pop(); } catch(char* p) { cout << p << endl; } cout << S1.top() << endl; try { S1.pop(); } catch(char* p) { cout << p << endl; } cout << S1.top() << endl; try { S1.pop(); } catch(char* p) { cout << p << endl; } cout << S1.top() << endl; try { S1.pop(); } catch(char* p) { cout << p << endl; } cout << S1.top() << endl; try { S1.pop(); } catch(char* p) { cout << p << endl; }; cout << S1.top() << endl; try { S1.pop(); } catch(char* p) { cout << p << endl; } try { S1.pop(); } catch(char* p) { cout<<p<<endl; } try { S1.pop(); } catch(char* p) { cout << p << endl; } //try{ S1.pop(); }catch(char * p){ cout<<p<<endl;} //try{ S1.pop(); }catch(char * p){ cout<<p<<endl;} //utolsó elem kivétele, size 0 lesz //try{ S1.pop(); }catch(char * p){ cout<<p<<endl;} //pop kivétel próbája S1.WriteSize(); cout << "Az utolso elem: " << S1.top() << "\n"; try { S1.SetCapacity(3); } catch(char* p) { cout << p << endl; } cout << "Ertekado op." << endl; cout << "Utolso elem S2-ben:" << S2.top() << endl; S2.WriteSize(); cout << "\n\nKet elem kozotti muveletek tesztelese: osszeadas" << endl; cout << S1.top() << " + " << S1.top2() << " = "; try { cout << S1.plus() << endl; } catch(char* p) { cout << p << endl; } cout << "\n\nKet elem kozotti muveletek tesztelese: osszeszorzas" << endl; cout << S1.top() << " * " << S1.top2() << " = "; try { cout << S1.multiply() << endl; } catch(char* p) { cout << p << endl; } cout << "\n\nKet elem kozotti muveletek tesztelese: kivonas (A-B)" << endl; cout << S1.top() << " - " << S1.top2() << " = "; try { cout << S1.A_minus_B() << endl; } catch(char* p) { cout << p << endl; } cout << "\n\nKet elem kozotti muveletek tesztelese: kivonas (B-A)" << endl; cout << S1.top2() << " - " << S1.top() << " = "; try { cout << S1.B_minus_A() << endl; } catch(char* p) { cout << p << endl; } cout << "\n\nKet elem csereje" << endl; cout << "A: " << S1.top() << ", B: " << S1.top2() << endl; S1.csere(); cout << "A: " << S1.top() << ", B: " << S1.top2() << endl; cout << "\n\n * operator teszt S1-t megszorozzuk 2.0-val" << endl; cout << "Alap szam: " << S1.top() << "," << S1.top2() << endl; //S1.kiir(); S1 = (2.0 * S1); //S1.kiir(); cout << "Megszorzott szam: " << S1.top() << "," << S1.top2() << endl; cout << "\nKet stack osszeadasa:" << endl; S5 = (S3 + S4); cout << "Ket legfelso elem: " << S3.top() << " + " << S4.top() << " = " << S5.top() << endl; cout << "\nKet stack osszeszorzasa:" << endl; S6 = (S3 * S4); cout << "Ket legfelso elem: " << S3.top() << " * " << S4.top() << " = " << S6.top() << endl; cout << "\nKet stack abszolutertekes kivonasa:" << endl; S7 = (S3 - S4); cout << "Ket legfelso elem: " << S3.top() << " - " << S4.top() << " = " << S7.top() << endl; system("pause"); return 0; }

    stack.h
    #ifndef _STACK_H #define _STACK_H #include <iostream> #include <assert.h> //#include <math.h> using namespace std; //Template, hogy típusfüggetlen legyen template <class T> class Stack { T* buff; int size; int capacity; public: //konstruktorok, destruktor Stack() {buff = new T[1]; size=0; capacity=0;}; Stack(int i); Stack(const Stack<T>&); ~Stack(){delete [] buff;}; void SetCapacity(int i); //alapműveletek (pop, push, top) T pop(); T top(); void push(T value); //visszaadja felülről a 2. elemet T top2(); //műveletek, az első 2 elemmel (utolsó elem: A, köv.: B) T plus(); //összeadás T A_minus_B(); //kivonás: A-B T B_minus_A(); //kivonás: B-A T multiply(); //szorzás T A_div_B(); //osztás: A/B T B_div_A(); //osztás: B/A void csere(); //mérettel kapcsolatos műveletek, kiírás int empty(); void WriteSize(); void kiir(); // egyéb műveletek T abs(const T& x); //operátorok Stack<T>& operator=(Stack<T>&); bool operator==(Stack<T>&); //számmal szorzás template <class U> friend Stack<U>& operator*(U value, Stack<U>& other); //műveletek két stackkel//////////////////////////////////// //összeadás template <class U> friend Stack<U>& operator+(const Stack<U>&, const Stack<U>&); //abszolútértékes kivonás template <class U> friend Stack<U>& operator-(const Stack<U>&, const Stack<U>&); //összeszorzás template <class U> friend Stack<U>& operator*(const Stack<U>&, const Stack<U>&); //////////////////////////////////////////////////////////// }; //konstruktor 2 template <class T> Stack<T>::Stack(int i) { capacity = i; if (this->capacity <= 0) { buff = new T[1]; } else { buff = new T[i]; } size = 0; }; //konstruktor 3 template <class T> Stack<T>::Stack(const Stack<T>& s) { capacity = s.capacity; size = s.size; if (capacity <= 0) buff = new T[1]; else { buff = new T[capacity]; int i = 0; while (i < this->size) { buff[i] = s.buff[i]; i++; } } } template <class T> Stack<T>& Stack<T>::operator=(Stack<T> & s) { int len = s.size; delete [] buff; buff = new T[len]; size = s.size; capacity = s.capacity; int i = 0; while (i < len) { buff[i] = s.buff[i]; i++; } return *this; } template <class T> T Stack<T>::pop() { if (size <= 0) { throw "Nincs torlendo adat!"; } else { size--; } return this->buff[size]; } template <class T> T Stack<T>::top() { assert(size>0); return buff[size-1]; //if (size<=0) throw "Meg nincs adat a stackben!"; //else return this->buff[size-1]; } template <class T> void Stack<T>::push(T value) { if (size >= capacity ) { throw "Megtelt a Stack!"; } else { buff[size] = value; size++; } } template <class T> void Stack<T>::SetCapacity(int i) { if (i <= size) { throw "Ervenytelen capacity beallitas (nem lehet kisebb vagy egyenlo a meretnel)"; } else { capacity = i; } } template <class T> int Stack<T>::empty() { return (size == 0) ? 1 : 0; } template <class T> void Stack<T>::WriteSize() { if ((this->empty())) { cout << "A Stack ures.\n"; } else { cout << "A Stackben "<< size <<" darab elem van.\n"; } } //stack elemeinek kiírása template <class T> void Stack<T>::kiir() { int i=0; cout << "A stack elemei:" << endl; while (i < size) { cout << buff[i] << endl; i++; } } // függvénysablon az abszolútérték kiszámítására template <class T> T abs(const T& x) { return (x >= 0) ? x : -x; } //2. elem visszaadása template <class T> T Stack<T>::top2() { assert(size > 1); return buff[size-2]; } //két legfelső elem összeadása template <class T> T Stack<T>::plus() { if (size < 2) { throw "Nincs mit osszeadni (kevesebb mint 2 elem van)."; } else { return (this->top())+(this->top2()); } } //a két legfelső elem összeszorzása template <class T> T Stack<T>::multiply() { if (size < 2) { throw "Nincs mit osszeszorozni (kevesebb mint 2 elem van)."; } else { return (top() * top2()); } } //A-B kivonás (stack: A,B,.....) template <class T> T Stack<T>::A_minus_B() { if (size < 2) { throw "Nincs mit kivonni (kevesebb mint 2 elem van)."; } else { return (top() - top2()); } } //B-A kivonás (stack: A,B,.....) template <class T> T Stack<T>::B_minus_A() { if (size < 2) { throw "Nincs mit kivonni (kevesebb mint 2 elem van)."; } else { return (top2() - top()); } } //két legfelső elem cseréje template <class T> void Stack<T>::csere() { T temp, temp2; if (size < 2) { throw "Nincs miket felcserélni (kevesebb mint 2 elem van)."; } else { temp = pop(); temp2 = pop(); push(temp); push(temp2); } } template <class U> Stack<U>& operator*(U value, Stack<U>& other) { Stack<U> m_Stack_s(other.capacity); Stack<U>* rev_Stack = new Stack<U>(m_Stack_s.capacity); // Stack<U> rev_Stack(m_Stack_s.capacity); while (other.size > 0) { m_Stack_s.push(other.pop() * value); } while (m_Stack_s.size > 0) { rev_Stack->push(m_Stack_s.pop()); // rev_Stack.push(m_Stack_s.pop()); } return *rev_Stack; } //két stack összeadása 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(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 <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(a_s.pop() * b_s.pop()); } //sorrend megfordítása while(ret_Stack_s.siz
    Mutasd a teljes hozzászólást!
  • Es hol fogod torolni az operator*-ban new-el letrehozott peldanyt..?
    Mutasd a teljes hozzászólást!
  • Igen az valóban úgy lehet. Az általad most jelölt topic kapcsán még akkor utánanéztem, de nem volt időm és energiám kipróbálni. Én itt olvastam róla.
    Mutasd a teljes hozzászólást!
  • Én itt olvastam róla.


    Ezt en is megtalaltam a napokban valamelyik tema kapcsan...
    Mutasd a teljes hozzászólást!
  • Most ezt ki is kipróbáltam:

    template <class T> class Stack; template <class T> Stack<T> operator*(const Stack<T>& s, const T& t); template <class T> class Stack { public: Stack(void) { } Stack(const Stack&) { } ~Stack(void) { } Stack& operator =(const Stack&) { return *this; } friend Stack<T> operator *<T>(const Stack<T>& s, const T& t); }; template <class T> Stack<T> operator *(const Stack<T>& s, const T& t) { return Stack<T>(); } template <class T> inline Stack<T> operator *(const T& t, const Stack<T>& s) { return s*t; } int main(int argc, char *argv[]) { Stack<double> s1, s2; s1 = s1 * 2.0; s2 = 3.0 * s2; return 0; }

    Mutasd a teljes hozzászólást!
  • Sziasztok!

    Először is Mindenkinek Kellemes Húsvéti Ünnepeket Kívánok!

    Másodszor: ti aztán kitettetek magatokért :))
    klorand válaszára beraktam oda egy const-ot, most lefordítja, csak valami hülye hibát ad futtatásnál.
    Mindjárt letöltöm és kirpróbálom a 4.3.3as g++-t.
    (de pl. MinGW 5.1.6 is ugyanazt a hibát dobta mint Dev-Cpp (This application has requested the Runtime to terminate it in an unusual way. Please contact the application's support team for more information.))

    Kérdésem hogy a gcc, és g++ ugyanaz ? Tudom buta kérdés, de eddig csak VS-ben, és néha devcpp-ben fordítottam no :) (azért kérdem, mert a rendszer, ahova majd fel kell tölteni gcc 4.1.2-t és GNU libc 2.9-et használ, és ezért szeretném ezekre is megcsinálni hogy 100%-osan (warning és error nélkül) forduljon, illetve fusson)

    A pontot klorand javaslatára old sharky-nak adom, de mindenkinek köszönöm, aki segített.
    Mutasd a teljes hozzászólást!
  • Kérdésem hogy a gcc, és g++ ugyanaz ?


    Döntsd el te!
    gcc
    g++

    A pontot klorand javaslatára old sharky-nak adom


    Ez a mondat így nekem egy kis kellemetlen érzés benyomását kelti - mintha rá lennék szorulva azokra a pontokra - mindenesetre ennek ellenére köszönöm!
    Mutasd a teljes hozzászólást!
  • okés, így már értem :))

    Nem azért, mert rá vagy szorulva, csak nem nagyon tudtam volna egyedül dönteni, hogy kié a pont
    (tudod, sok itt az okos ember, és én ahogy olvasom a kommenteket, úgy vélem hogy mindenkinek igaza van )
    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