konstruktor és destruktor osztaly::tagfuggveny formában az osztály leírásában

C/C++

Sziasztok!

Ezen az oldalon:
http://209.85.129.104/search?q=cache:BwKToFMwucYJ:www.keil.com/support/…

találtam az alábbi részletet: 


class clf  {
  public:
   clf();               // Constructor (ctor)
  ~clf();               // Destructor (dtor)
   int   n1, n2, n3;
};

clf::clf ()  {          // define ctor
  n1 = n2 = n3 = 0;
}

clf::~clf()  {          // define dtor
}

clf clf1;               // class object

int main (void)  {
  return (0);
}

Miért kell az osztály leírása után külön definiálni a konstruktort és a destruktort?
Az osztálydefiníción belül nem lehet? És akkor nem kéne a láthatósági(?) operátort (::) használni. Ha itt a dupla kettőspont nem láthatósági operátor, akkor elnézést!

Szóval az alábbi példa miért rossz? 


class clf  {
  public:
   clf()                // Constructor (ctor)
        {
         n1 = n2 = n3 = 0;
        }               
  ~clf();               // Destructor (dtor)
   int   n1, n2, n3;
};

clf clf1;               // class object

int main (void)  {
  return (0);
}

Köszi a választ!

  • 1635 megtekintés

( Andrei | 2008. 02. 27., sze – 17:41 )

Mind a ket verzio jo, de amikor kivul definialod a tagfuggvenyeket, akkor lehetoseged van arra, hogy a deklaracio es a definicio kulon allomanyban legyen. Ez meg azt teszi lehetove, hogy a leforditott koddal csak a deklaraciokat kell csak adni az osztaly felhasznaloinak. Igy a clf osztaly implementaciojanak hipertitkos reszleteit csak disassemblerrel lehet kideriteni. :)

Van meg egy elonye a kulon file-ban torteno definicionak: ha valtozik az implementacio, de az osztaly interfesze nem, akkor egyszeru ujralinkelessel (dinamikus linkeles eseten meg az sem kell) maris lehet hasznalni, nem kell ujraforditani a cuccot. Ez mondjuk nem mukodik ilyen szepen, de anno azt szerettek volna az okosok ha igy mukodne. Ettol is elcseszett egy kicsit a c++.

( turul16 v | 2008. 02. 27., sze – 17:57 )

Template-eknel kenyelmesebb 2. felekeppen, es nincs is sok ertelme masutt implementalni.

A peldad azert rosz, mert csak egy fejet adtal meg detruktornak. ~clf(){}; vagy nem is kell oda.

Azert nem jo igy deklaralni, mert egy masik forditasi egysegbol(c++ file) akkor, hogy ered el az ossztalyt ?
Erdemes header-be kitolni a deklaraciot es valamelyik c++ forras fileban implemantalni.

( xcom | 2008. 02. 27., sze – 19:04 )

A peldad jo, de a destruktor nincs definialva. Egy kis kiegeszites: 


class clf  {
  public:
   clf();               // Constructor (ctor)
  ~clf();               // Destructor (dtor)
   int   n1, n2, n3;
};

clf::clf(){};
clf::~clf(){};

A kettospontok azert kellenek, mert mar kivul vagy az osztalyon, meg kell mondani, hogy mit is definialsz.

Ha rogton definialni is szeretned a konstruktort/destruktort:
class clf{
   clf(){};               // Constructor (ctor)
  ~clf(){};               // Destructor (dtor)
[...]
};

Tehat ket fele keppen is lehet. Definicio lehet a deklaracioval egyutt, vagy kulon (masik fileban, libraryban, mindegy). Lenyeg, hogy csak egy legyen :)

Member valtozoknak pedig erteket igy is lehet adni: 


  clf():n1(0),n2(0),n3(0){};

Az osztaly helyesen: 


class clf  {
public:
  clf():n1(0),n2(0),n3(0){};               // Constructor (ctor)
  ~clf(){};                                // Destructor (dtor)

  int   n1, n2, n3;
};

Andras

( zleho | 2008. 02. 27., sze – 19:26 )

en ugy tudom, hogyha osztalydefinicion belul definialod a tagfv-t (legyen ez akar konstruktor, akar destruktor), akkor az azt teszi, mintha te a kodban osztalydefinicion kivul definialnad a fv-t inline kulcsoszoval
bovebben az inline fuggvenyekrol itt: http://en.wikipedia.org/wiki/Inline_function

Otthon utánaolvastam és én is azt találtam, hogy ha egyszerre van deklarálva és definiálva, vagyis a definiálod az osztályt, akkor a tagfüggvények inline függvények lesznek. És megtaláltam azt is, hogy a saját gyakorló kódomban mi volt a baj. Ha függvényt raktam fejállományba ÉS cpp állományba, akkor a fejállományban deklaráltam, a cpp fájlban, amiből object-et lehet fordítani, pedig definiáltam a függvényt. Viszont az nem esett le, hogy osztály esetén a deklarációban megadom az osztály szerkezetét, de a deklarációban már magát a szerkezetet nem írom le mégegyszer, csak a tagfüggvényeket fejtem ki és ezért van szükség a láthatósági(?) hatókör(?) operátorokra a tagfüggvény neve előtt. Ezt nem értettem még tegnap.
--
unix -- több, mint kód. filozófia.
Life is feudal

Nem hülyeség, inline lesz. Ettől még veheted pl. a címét, mert legfeljebb lesz egy "normál" függvény is a tárgykódban, amit indirekt címzéssel tud hívni, ahol meg teheti, kifejti a függvényt a kódban. Gondolom, ez már compiler-függő amúgy.

Szerk.:
Ráadásul az inline csak egy kérés, amit a compiler vagy teljesít vagy nem.

Inline functions, though declared that way, are not always inlined. It is not always necessary to declare a function as inline. Any function whose body is defined within the class body will be implicitly treated as inline. But there is a catch to this. The implicit treatment depends on the complexity and length of the function. Remember who is the boss when it comes to inline functions? Inline is just a request and it is the compiler who is vested with the authority to accept or reject the inline request.

KisKresz