3. C++ Operator [] überladen

C++ Operator [] überladen

  • T

    Sone schrieb:

    Was zum Teufel willst du mit der Adresse einer konstanten Variable?

    Ist doch ganz klar:

    (*(char*)(&lolwat[22])) = 'C';
    0
  • S

    theliquidwave schrieb:

    Sone schrieb:

    Was zum Teufel willst du mit der Adresse einer konstanten Variable?

    Ist doch ganz klar:

    (*(char*)(&lolwat[22])) = 'C';

    Ich hoffe das ist jetzt nicht dein Ernst.

    In einem konstanten Objekt sind auch alle Member (zumindest die, die nicht als mutual deklariert wurden) konstant.

    Und der Standard sagt

    any attempt to modify a const object during its lifetime (3.8) results in undefined behavior

    0
  • S

    ok, ich änders

    template<class T>
class Foo {
public:
    ...
    const T& operator[](std::size_t position) const
    {
        ...
        ...
        ...
        return vec[position];
    }

    T& operator[](std::size_t position)
    {
        return const_cast<T&>(static_cast<const Foo&>(*this)[position]);
    }
...
};
    0
  • S

    Neh, ich will jetzt mal hören wieso das so viel Sinn macht. Von cooky seiner Majestät höchstpersönlich.

    0
  • S

    Sone schrieb:

    Von cooky seiner Majestät höchstpersönlich.

    bow down before her !

    0
  • T

    Sone schrieb:

    Ich hoffe das ist jetzt nicht dein Ernst.

    Gut bemerkt 😃

    0
  • Mod

    Sone schrieb:

    Neh, ich will jetzt mal hören wieso das so viel Sinn macht. Von cooky seiner Majestät höchstpersönlich.

    Ich, der Kaiser des Universums, sage Euch, Sone, dass Ihr wieder mal mehr Mario Barth angucken solltet:

    void alte_c_funktion(const char* data, int N);

vector<char> foo(500);
// [...]
alte_c_funktion(&foo[0], 500);

    Hat wohl jeder schon 1000 Mal gebraucht.

    0
  • C

    Sone schrieb:

    Neh, ich will jetzt mal hören wieso das so viel Sinn macht. Von cooky seiner Majestät höchstpersönlich.

    1. Konzeptuell modelliert ein vector, wie fast alles mit operator[], eine Art Arrayzugriff. In jedem fall möchte man mit [] auf ein Element selbst zugreifen - und das wird eben genau mit einer Referenz erreicht. Äquivalent steht dazu das Ziel von C++, Klassentypen als Built-In Typen zu behandeln. (Bei einem konstanten Array gibt es natürlich auch einen const&.) Eine konstante Referenz ist also nur konsistent mit dem Rest der Sprache.

    2. Praktisch gesehen willst du uU mal sowas:

    send(&v[5], xyz);

    Ja, man kann auch v.data() + 5 schreiben, aber da könnte man ja auch *(v.data() + 5) = 77 bei non-const schreiben. Der Punkt ist, dass das nicht das Verhalten ist, was man erwartet.

    0
  • K

    Sone schrieb:

    In einem konstanten Objekt sind auch alle Member (zumindest die, die nicht als mutual deklariert wurden) konstant.

    Und der Standard sagt

    any attempt to modify a const object during its lifetime (3.8) results in undefined behavior

    Mal abgesehen davon, dass keiner ernsthaft das machen will, was liquidwave scherzhafterweise geschrieben hat, bist du hier auf dem Holzweg; denn

    void ok(const char& ref)
{
  const_cast<char&>(ref) = 'y';
}

int main()
{
  char c = 'x';
  ok(c);
}

    ist 100%ig legal, weil c kein "const object" ist. Nur weil du eine "Referenz auf const" oder "Zeiger auf const" hast, heißt das nicht, dass das referenzierte Objekt ein "const Objekt" ist. "Const Objekte" sind nur die, die schon mit einem const angelegt werden. Erst wenn du bei der Deklaration von c noch ein const davor schreibst, ist c ein "const object" und erst dann greift das, was du aus dem Standard zitiert hast. Bei einem vector<char> ist das sehr ähnlich. Die char-Objekte da drin sind keine "const objects".

    0
  • S

    . (s. u., hat sich geklärt)

    0
  • C

    Wo ist der Unterschied zwischen einem TextBlock und einem vector<char>?

    0
  • S

    das war 1zu1 das beispiel aus dem meyers...
    der hat sein textblock beispiel schon öfters mal vorher benutztund auch eingeführt.

    klar machst es bei den simplen datentypen wenig sinn. aber es ging um das prinzip, daher mein code mit dem template später.

    0
  • S

    cooky451 schrieb:

    Sone schrieb:

    Neh, ich will jetzt mal hören wieso das so viel Sinn macht. Von cooky seiner Majestät höchstpersönlich.

    1. Konzeptuell modelliert ein vector, wie fast alles mit operator[], eine Art Arrayzugriff. In jedem fall möchte man mit [] auf ein Element selbst zugreifen - und das wird eben genau mit einer Referenz erreicht. Äquivalent steht dazu das Ziel von C++, Klassentypen als Built-In Typen zu behandeln. (Bei einem konstanten Array gibt es natürlich auch einen const&.) Eine konstante Referenz ist also nur konsistent mit dem Rest der Sprache.

    2. Praktisch gesehen willst du uU mal sowas:

    send(&v[5], xyz);

    Ja, man kann auch v.data() + 5 schreiben, aber da könnte man ja auch *(v.data() + 5) = 77 bei non-const schreiben. Der Punkt ist, dass das nicht das Verhalten ist, was man erwartet.

    Hmm, zugegeben, wenn ich mir das so durchlese, sehe ich langsam ein dass du Recht hast.

    0
  • V
     

    template<class T,std::size_t D>
class Array
{
  vector<T>* vec;

  public:
  // 1. einen Konstruktor Vector() besitzen, der den Inhalt mit Nullen initialisiert
  Array()
  {
    this->vec = new vector<T>(D,0);
  }  

  public: 
  // 2. den Index-Operator [] überladen, damit man auf die einzelnen Elemente des Vektors zugreifen kann.
  T& operator [] (std::size_t i) 
  { 
    return vec[i]; 
  } 

  public: 
  // 2. den Index-Operator [] überladen, damit man auf die einzelnen Elemente des Vektors zugreifen kann.
  const T& operator [] (std::size_t i) const 
  { 
    return vec[i]; 
  }

  public:
  // 3. den Additionsoperator + überladen, so dass man mit den entsprechenden Aufrufen Vektoren addieren kann.
  Array<T,D>& operator + (Array<T,D>& input)
  {
    Array<T,D> temp;
    for(long i = 0; i < D; i++)
      temp[i] = this[i] + input[i];
  }

  public:
  // 5. eine Funktion length() besitzen, die einem die Länge des Vektors (euklidische Norm) zurückgibt.
  long length()
  {
    double l = 0.0;
    for(long i = 0; i < D; i++)
      l += pow(this[i],2);
    l = sqrt(l);

    return D;
  }

  public:
  // 6. eine Funktion print() besitzen, die den Inhalt des Vektors auf dem Bildschirm ausgibt.
  void print()
  {
    for(long i = 0; i < D; i++)
      cout<<"["<<*this[i]<<"]";
    cout<<endl;
  }
};

    Der vector vec soll direkt per []-Operator gelesen/beschrieben werden können. Wo ist mein Fehler?

    Vielen Dank für Eure Hilfe.

    0
  • C

    Wozu der Pointer und der new Kram?

    0
  • P

    @Sone: Die const Referenz wird aber von der non-const Methode zu einer normalen Referenz gecasted, was unmöglich wäre wenn die const Methode einfache char zurückgibt.

    0
  • V

    Höchstwarscheinlich weil ich es nicht besser kann ;). Falls ich es direkt initialisieren kann nur her mit Lösungen =). Ich denke ich muss nicht bemerken das ich Anfänger bin...

    0
  • S

    pyhax schrieb:

    @Sone: Die const Referenz wird aber von der non-const Methode zu einer normalen Referenz gecasted, was unmöglich wäre wenn die const Methode einfache char zurückgibt.

    Ach Mist! Das hab ich völlig übersehen 😃

    0
  • C
     

    template <typename T, std::size_t S>
class Array
{
  std::vector<T> v_;

public:
  Array()
    : v_(S) // "Initialisierungsliste"
  {}
};

    Kommst du von Java oder so? In C++ sind Pointer eher selten.

    Edit: Von den anderen Methoden her macht ein std::vector im Übrigen wenig Sinn. Da wäre eher sowas angebracht:

    template <typename T, std::size_t S>
class Array
{
  std::array<T, S> v_;
};
    0
  • S

    cooky, meinst du nicht eher: Speicher selbst allokieren (und damit verwalten) ist in C++ eher unüblich?

    P.S.: Ein Hinweis auf C++11 wäre angebracht, ist ja noch Anfänger... (wegen std::array )

    0
Anmelden zum Antworten