C++ Tutorial

[Xeon]

Hier der Link:
https://www.proggen.org/doku.php?id=cpp ... e:multiple

Da hast du wahrscheinlich bei GetMegaPixel() das Schlüsselwort inline davor vergessen?

Code: Alles auswählen

class Display
{
public:
  int ResolutionX;
  int ResolutionY;
 
  double GetMegaPixel()
  {
    return double(ResolutionX * ResolutionY) / 1000000.0;
  }
 
  Display( int x, int y )
  : ResolutionX( x )
  , ResolutionY( y )
  {}
};

Wenn ja, dann ändere ich es für dich.

[Xeon]

Hallo Xin

Hier der Link:
https://www.proggen.org/doku.php?id=cpp:overload:start

Hier der Code:

Code: Alles auswählen

class MyInteger
{
private:
  int Value;
public:
  MyInteger( int value ) : Value( value ) {}
 
  Print();
  Print( int j = 0 );
};
 
void MyInteger::Print()
{
  printf( "Integer: %d\n", Value );
}
 
void MyInteger::Print( int j )
{
  printf( "Integer addiert: %d\n", Value + j );
}
 
int main()
{
  MyInteger myInt;
 
  myInt.Print();
 
  return 0;
}

Mir ist klar das der Default-Parameter weg muss, aber trotzdem sind in dem Code weiterhin Fehler.

In der Klasse MyInteger fehlt bei den Methoden der Datentyp void.
In der Funktion main fehlt bei myInt das Argument, ich habe einfach mal als Wert die 4 genommen.
Die Header-Datei habe ich auch mal eingefügt.

So müsste es richtig sein:

Code: Alles auswählen

#include <stdio.h>

class MyInteger
{
private:
  int Value;
public:
  MyInteger( int value ) : Value( value ) {}

  void Print();
  void Print( int j = 0 );
};

void MyInteger::Print()
{
  printf( "Integer: %d\n", Value );
}

void MyInteger::Print( int j )
{
  printf( "Integer addiert: %d\n", Value + j );
}

int main()
{
  MyInteger myInt(4);

  myInt.Print();

  return 0;
}

Der Compiler gibt jetzt die richtigen Fehlermeldungen aus, habe ich recht?


Liebe Grüße
Xeon

[Xin]

Der Compiler gibt jetzt die richtigen Fehlermeldungen aus, habe ich recht?

In allen Punkten.

Ich sag ja, das Tutorial wird besser, wenn es jemand richtig durcharbeitet.
Wobei ich teils echt erschrocken bin, was du da an Fehlern findest.

[Xeon]

Hallo ich schon wieder.

Bin hier angelangt:

https://www.proggen.org/doku.php?id=cpp ... ace:access

Was bedeutet das Schlüsselwort protected?
Irgendwie habe ich noch keine Erklärung dazu gesehen. Kommt die Erklärung noch später im Tutorial?


Liebe Grüße
Xeon

[Xin]

Hallo ich schon wieder.

Bin hier angelangt:

https://www.proggen.org/doku.php?id=cpp ... ace:access

Was bedeutet das Schlüsselwort protected?
Irgendwie habe ich noch keine Erklärung dazu gesehen. Kommt die Erklärung noch später im Tutorial?


Liebe Grüße
Xeon

Guter Punkt...^^
Da klebt jetzt ein Postit mit "protected" an meinem Monitor...
Ich habe ihn bei Klassen noch nicht erklärt, weil protected erst bei Vererbung eine Rolle spielt, Vererbung an der Stelle aber noch nicht bekannt ist. Da muss ich noch ein kurzes Kapitel einfügen.

In Kurzfassung: protected bedeutet erstmal das gleiche wie private, man kommt also nicht von außen ran. Leitet man von der Klasse ab, werden darf die abgeleitete Klasse aber auf die Protected-Member der Basisklasse zugreifen. Sie sind also vor Zugriffen von außen geschützt, während Spezialisierungen direkten Zugriff haben.

[Xeon]

Hallo zusammen

Hier der Link:
https://www.proggen.org/doku.php?id=cpp:const:start

Hier der Code:

Code: Alles auswählen

int                 variableValue;
int const           constantValue;
 
int       *         pointerToVariableValue;
int const *         pointerToConstantValue;
int       * const   constantPointerToVariableValue;
int const * const   constantPointerToConstantValue;
 
int const * const * variablePointerToConstantPointerToConstantValue;

Ich weißt was ein konstanter Wert ist und was ein konstanter Zeiger. Nur die letzte Zeile verstehe ich nicht:

Code: Alles auswählen

int const * const * variablePointerToConstantPointerToConstantValue;

Kann mir das jemand erklären?


Liebe Grüße
Xeon

[nufan]

Du kannst einen Zeiger auf eine Variable zeigen lassen:

Code: Alles auswählen

Zeiger -> Variable

Du kannst ihn aber auch auf einen Zeiger zeigen lassen:

Code: Alles auswählen

Zeiger -> Zeiger -> Variable

Die Deklaration (vorerst ohne "const") sieht dann so aus:

Code: Alles auswählen

int ** pointerToPointerToValue;

Nun kannst du das "const"-Attribut für folgende Zugriffe verwenden:
* Den Zeiger auf den Zeiger
* Den Zeiger auf die Variable
* Den Wert der Variable

Im von dir genannten Beispiel wird "const" für die unteren beiden Punkte verwendet. Du kannst also auf andere Zeiger verweisen, diese aber nicht verändern.

Ein Beispiel dazu:

Code: Alles auswählen

int main()
{
    int                 variableValue;
    int                 anotherVariableValue;
    int const * const   constantPointerToConstantValue = &variableValue;
    int const * const   anotherConstantPointerToConstantValue = &anotherVariableValue;
    int const * const * variablePointerToConstantPointerToConstantValue;

    // Der Zeiger auf den Zeiger ist nicht konstant, es können beliebige Werte zugewiesen werden.
    variablePointerToConstantPointerToConstantValue = &constantPointerToConstantValue;
    variablePointerToConstantPointerToConstantValue = &anotherConstantPointerToConstantValue;

    // Der Zeiger auf die Variable ist konstant, es kann kein neuer Wert zugewiesen werden.
    *variablePointerToConstantPointerToConstantValue = 1;   // Compiler-Fehler

    // Der Wert der Variable ist konstant, es kann kein neuer Wert zugewiesen werden.
    **variablePointerToConstantPointerToConstantValue = 1;  // Compiler-Fehler

    return 0;
}

Hilft dir das?

[Xin]

Da war nufan dann schneller.

[Xeon]

Hilft dir das?

Danke nufan, du hast mir weiter geholfen.

[Xeon]

Ich schon wieder.

Hier der Link:
https://www.proggen.org/doku.php?id=c:f ... qualifiers

Dieser Text leuchtet mir nicht ganz ein:

Konstant, aber doch veränderlich
Nicht alle Datensätze müssen in einem konstanten Objekt unveränderlich sein. Eine Liste kann zum Beispiel konstant sein, wenn kein Element hinzugefügt oder gelöscht wird. Der Zeiger auf ein aktuelles Element darf sich unter Umständen aber doch verändern. So kann man die Variablen, die den Wert der Instanz nicht verändern als mutable kennzeichnen. Diese Mutable-Variablen dürfen dann auch von Funktionen geändert werden, die als const gekennzeichnet sind:

Kann das sein dass dieses Wort "nicht" welches ich unterstrichen habe nicht dazu gehört?


Liebe Grüße
Xeon