„Csak guruknak” – konyhanyelven…

[pointux]

namespace Jo_Hosszu_NamSpace {

class Buffer {
protected:
size_t _size;
void * _buffer;

public:
~Buffer (); // Egyebek

void * operator * (); // Ill. const, ami kell

static std::auto_ptr create ( size_t size ); // Referencia mutató

protected:
Buffer ( size_t size ); // Konstruktor (a create hívja meg, de ez most lényegtelen)
};

}
[/CODE]

[CODE=main.c]
// 10 elemű puffer létrehozása, referencia mutatóval
std::auto_ptr buf = Jo_Hosszu_NamSpace::Buffer::create ( 10 );

// Az elemek elérése (ez a lényeg :))
int i = * ( int * ) * (* buf);

/* a 1. * &Buffer miatt (auto_ptr),
a 2. * a mi * operátorunk,
az (int *) a void *-ot konvertálja int *-gá
a 3. *-gal kaphatjuk meg a int változót (az int * mutatóból)
(Persze lehet variálni []-ekkel is :))
[/CODE][CODE=Buffer.h]
namespace Jo_Hosszu_NamSpace {

class Buffer {
protected:
size_t _size;
void * _buffer;

public:
~Buffer (); // Egyebek

void * operator * (); // Ill. const, ami kell

static std::auto_ptr create ( size_t size ); // Referencia mutató

protected:
Buffer ( size_t size ); // Konstruktor (a create hívja meg, de ez most lényegtelen)
};

}
[/CODE]

// 10 elemű puffer létrehozása, referencia mutatóval
std::auto_ptr buf = Jo_Hosszu_NamSpace::Buffer::create ( 10 );

// Az elemek elérése (ez a lényeg :))
int i = * ( int * ) * (* buf);

/* a 1. * &Buffer miatt (auto_ptr),
a 2. * a mi * operátorunk,
az (int *) a void *-ot konvertálja int *-gá
a 3. *-gal kaphatjuk meg a int változót (az int * mutatóból)
(Persze lehet variálni []-ekkel is :))
[/CODE][CODE=main.c]
// 10 elemű puffer létrehozása, referencia mutatóval
std::auto_ptr buf = Jo_Hosszu_NamSpace::Buffer::create ( 10 );

// Az elemek elérése (ez a lényeg :))
int i = * ( int * ) * (* buf);

/* a 1. * &Buffer miatt (auto_ptr),
a 2. * a mi * operátorunk,
az (int *) a void *-ot konvertálja int *-gá
a 3. *-gal kaphatjuk meg a int változót (az int * mutatóból)
(Persze lehet variálni []-ekkel is :))
[/CODE]

[zoltan22]

Ez tetszik. 🙂

Jut eszembe: ha a mutatok indexeleset akarom felulbiralni(?)(=”overload”), akkor mit kellene tenni?

Code:

class foo {
private:
int valami;
// lenyegtelen…
};

int main(void){
//…
foo b, *a = new foo[10];
a[1] = b; // en azt akarom, hogy igy a tomb _elso_ elemet lehessen igy elerni.
//…
return 0;
}

[pointux]

Gondolom erre gondoltál:

Code:

class foo {
    protected:
        int *valami;

    public:
        int &operator[] ( size_t n ) {
            return this->valami [ n ];
        }
}

Code:

foo [ 1 ] = 5;

[zoltan22]

Nem igazan. Attol lenne szo, hogy: adott egy osztaly. Bejelentek egy mutatot arra az osztalyra. A mutato egy tombre mutat, aminek az elemei az adott osztaly tipusuak. Mint tudjuk, igy a mutatot lehet indexelni. Az lenne a kerdes, hogy egy _mutato_ indexeles operatorat lehet-e felulbirlani?
Eselteg egy ilyennel ? Ezt a fordito nem hajlando megenni 🙁

Code:

class valami {
friend valami & operator [](valami*, int);
};

[gabaman]

„Bejelentek egy mutatot arra az osztalyra”
Ez így értelmetlen.

„Az lenne a kerdes, hogy egy _mutato_ indexeles operatorat lehet-e felulbirlani?”
Közvetlenül nem, mert nem osztály, hanem beépített minősítő a mutató (mint pl. a const). Viszont mutató helyett lehet használni osztályt (pl. Buffer), és ennek az indexelését lehet felülbírálni.

„Eselteg egy ilyennel ? Ezt a fordito nem hajlando megenni”
Nemis fogja. Nem tudom mi a szándékod, de ilyet lehet:

Code:

class valami: public Jo_Hosszu_NamSpace::Buffer {
    public:
    int & operator [](int) {
    // A Jo_Hosszu_NamSpace::Buffer::operator[]
    // helyett fog lefutni.
    }
};

Indexelés és értékadás túlterhelés kombinációja (vizsla kódját felhasználva – utólagos engedelmével):

Code:

class ElemKontener {
    protected:
  int & elem;

    public:
  ElemKontener (int & src):
  elem (src) {
    }

  int operator= ( size_t src ) {
// Pl. egyedi konverzió
if ( src > 1000 )
  std::cerr << "Hiba: " << src << std::endl;
else
  elem = (int)src;
  return elem;
  }

  int operator= ( char * src ) {
  std::string s ( src );
  if ( s.find_first_not_of ("-+0123456789e") != s.npos )
    std::cerr << "Hiba: " << src << std::endl;
    else
    elem = atoi ( src );
    return elem;
  }

  int operator= ( std::string src ) {
  if ( src == "egy")
  elem = 1;
  else if ( src.find_first_not_of ("-+0123456789e") != src.npos )
  std::cerr << "Hiba: " << src < () {
  return &elem;
  }
};

class foo {
    protected:
  int *valami;

    public:
  ElemKontener operator[] ( size_t n ) {
  return ElemKontener ( this->valami [ n ] );
  }
};

(Egy picit elcsúszott, hála a WYSIWYG módnak)

[zoltan22]

Értem, kösz 🙂

[gabaman]

Egy példa a friend használatára:

Code:

class ElemKontener {
friend class foo;
    protected:
  int & elem;

// Nem publikus konstruktor
  ElemKontener (int & src):
  elem (src) {
  }

private:
// Nem másolható!!!
  ElemKontener ( const ElemKontener & src);
  ElemKontener & operator = ( const ElemKontener & src);

    public:
  int operator= ( size_t src ) {
(…)

[gabaman]

Kinek mi a véleménye róla, hogy lehet szépen és biztonságosan használni egy C++ változót?

A variáns:

Code:

  int &operator[] ( size_t n ) {
  return valami [ n ];
  }

B variáns:

Code:

  int &operator[] ( size_t n ) {
  return this->valami [ n ];
  }

C variáns:

Code:

  int &operator[] ( size_t n ) {
  return foo::valami [ n ];
  }

[gabaman]

Egy kis pihent agyú puffer (csak a lényeges részt írom):  

Code:

class Buffer {
  protected:
  void * buf;
  public:
  HulyebiztosMutato operator* ();
};

template
class HulyebiztosMutato {
  protected:
  T * ptr;

  public:
  HulyebiztosMutato (T * p): ptr (p) {}

  inline T operator[] (int num) { return ptr[num]; }
  inline T operator* () { return *ptr; }
  inline T* operator-> () { return ptr; }
  void operator delete [] (void * p) {
    std::cerr << "Kedves programozó, menj inkább kapálni!" << std::endl;
    ::exit (666);
  }
  void operator delete (void * p) {
    std::cerr << "Kedves programozó, szúrd magad tökön mielőtt kapálni indulnál!" << std::endl;
    ::exit (-666);
  }
};

[pointux]

Code:

T* operator-> () { return ptr; }

Ez amúgy, hogy működne? A „->” vár még valamit nem?

Pl az auto_ptr

Code:

class Class {
int valami;
}

template class auto_ptr {
T* operator-> ()();
}

std::auto_ptr c;

c->valami;

[Szerző]

Bejegyzés