Gyakorló feladatok (4. hét)

Fontosabb kulcsszavak, fogalmak

• inicializáló lista
• másoló konstruktor, értékadó operátor
• destruktor
• operátorok túlterhelése
• implicit tagfüggvények és azok átdefiniálása
• statikus adattagok és tagfüggvények

Javasolt gyakorló feladatok

• Bevezető feladat: egyszerű osztály megvalósítása.
  Példa: Készítsen kör osztályt az alábbi műveletekkel:
  • inicializálható a sugár megadásával,
  • sugár lekérdezése/beállítása
  • kerület lekérdezése
  • terület lekérdezése, osztályon kívüli definícióval
  • kiírás ostream-re (pl. cout<<c)
  • + operátor, amelynek eredménye egy olyan kör, amelynek területe a két operandus területének összege.
• A statikus tag alkalmazása.
  Példa: Asztalokat akarunk nyilvántartani és minden pillanatban szeretnénk tudni, hogy hány asztalunk van. A feladat megoldásában használjuk a korábban készített String osztályt, vagy használhatjuk az STL-ből (Standard Template Library).
  
  
  

  ???

  #include <iostream>
  
  using std::ostream;
  using std::cout;
  using std::endl;
  typedef std::string String;  // string az STL-ból, ha nem a sajátunkat akarjuk használni. 
  
  class Asztal {
      static int db;
      String megn;
  public:
      Asztal(const char *n = "asztal") :megn(n) { db++; }
      Asztal(const Asztal& a) :megn(a.megn) { db++; }
      static int getDb() { return db; }
      const String& getNev() const { return megn; }
      ~Asztal() { --db; }
  };
  int Asztal::db = 0;
  
  void leltar(ostream& os = cout) {
      os << "Most " << Asztal::getDb() << " db asztalunk van." << endl;
  }
  
  ostream& operator<<(ostream& os, const Asztal& a) {
      os << "Ez egy " << a.getNev() << " ";
      leltar(os);
      return os;
  }
  
  int main() {
      Asztal k("kerekasztal"); cout << k;
      {
         Asztal a1("konyhaasztal"); cout << a1;
         Asztal a2 = a1; cout << a2;
         Asztal a3 = Asztal("dohanyzo"); cout << a3;
         a1 = a3; cout << a1;
         Asztal *ap = new Asztal; cout << *ap;
         delete ap; leltar();
         Asztal t[10]; cout << t[0];
      }
      leltar();
  
      return 0;
  }

• Dinamikus adattagú osztály.
  Példa: Készítsen vektor osztályt, ami valósakat tárol dinamikusan. (Lásd az előadáson elhangzott KomplexTar.) Műveletek:
  • konstruktor az elemszám és elemek kezdőértéke megadásával (utóbbi elhagyható, ekkor 0 a kezdőérték)
  • másoló konstruktor
  • értékadó operátor
  • destruktor
  • indexelő ([]) operátor, túl-/alulindexelés elleni védelemmel
  
  

  ???

  class Vektor {
      double *dp;         // itt lesznek az adatok
      unsigned int db;    // ennyi adatunk van
  public:
      Vektor(unsigned int n = 10) :db(n) {
          dp = new double[db];
      };
      Vektor(const Vektor&);
      Vektor& operator=(const Vektor&);
      double& operator[](unsigned int);
      const double& operator[](unsigned int) const;
      ~Vektor() { delete[] dp; }
  };
  
  /// másoló konstruktor
  /// Visszavezetjük az op=-re
  Vektor::Vektor(const Vektor& v) {
      dp = 0;     // delete hatástalanítása
      *this = v;  // op= hívása
  }
  
  /// értékadás
  Vektor& Vektor::operator=(const Vektor& rhs_v) {
      if (this != &rhs_v){// amennyiben nem önmagának ad értéket
          delete[] dp;    // régi terület törlése
          db = rhs_v.db;  // átvesszük a darabszámot a jobb oldali op-tól
          dp = new double[db];
          for (unsigned int i = 0; i < db; i++)
              dp[i] = rhs_v.dp[i];
      }
      return *this;
  }
  
  /// indexelés, képes nyújtózkodni
  double& Vektor::operator[](unsigned int ix) {
      if (ix >= db) {     // nyújtózkodni kell
          double *np = new double[ix+1];
          for (unsigned int i = 0; i < db; i++)
              np[i] = dp[i];
          delete[] dp;    // régi törölhető
          dp = np;        // ez lesz az új pointer
          db = ix+1;
      }
      return dp[ix];
  }
  
  /// konstans nem változhat
  const double& Vektor::operator[](unsigned int i) const {
      if (i >= db)
         throw "hibas index";
      return dp[i];
  }
  

• String rejtvény a 4. heti előadásról: Milyen függvények hívódnak meg, milyen sorrendben?
  

  class String {
    char *p;
    int size;
  public:
    String( );                        // 1
    String(const char *);             // 2
    String(String&);                  // 3
    ~String( );                       // 4
    String operator+(String&);        // 5
    char& operator[](int);            // 6
    String& operator=(const String&); // 7   -- alternatív: értékparaméterrel
  };
  
  int main() {
    String s1("rejtvény");
    String s2;
    String s3=s2;
  
    char c = s3[3];
    s2 = s3;
    s2 = s3 + s2 + s1;
  }
  

  A C++ szabvány megengedi, hogy hatékony működés érdekében ne hívódjon másoló konstruktor olyan ideiglenes objektumok esetében, amelyeknek szerepe csupán egy másik objektum inicializálása. Emiatt a ténylegesen meghívott függvények eltérhetnek a várttól. Ezt a viselkedést GCC használata esetén a g++ -fno-elide-constructors kapcsolójával ki lehet kapcsolni.
• Másik rejtvény: Mit ír ki a program a main() függvény egyes sorainak hatására?

  class A {
    int k;
  public:
    A(const int i = 0) :k(i){ cout << 'k'; }
    A(const A& a) { k = a.k; cout << 'c'; }
    void operator=(A& a) { k = a.k; f(a); cout << 'e'; }
    A& operator*(int i) { cout << i*100; return *this; }
    void f(A a) { k++; cout << 'f'; }
    ~A() { cout << 'd'; }
  };
   
  A& operator*( int i, A& a ) { cout << i; return a; }
   
  int main() {
     A a = A(1);   cout << '\n';    // ______
     a = a * 2; cout << '\n';       // ______
     a = 3 * a; cout << '\n';       // ______
  }                                 // ______