in unserem Code muss ich oft sowas lesen:

#define NUMBER 4711

void doSomething( int iNumber );

doSomething( NUMBER);

Mir ist schon klar, dass das define mit const int erstetzt werden sollte. Allerdings habe ich eine Vorstellungsproblem.

Der Präprozesser erstetzt NUMBER mit 4711, aber von welchem Typ ist NUMBER? Was passiert wenn doSomething aufgerufen wird? Findet ein impliziter Cast statt?

Danke
Lord Hong

Der Präprozesser erstetzt NUMBER mit 4711, aber von welchem Typ ist NUMBER?

Na, von welchem Typ ist 4711?

hängt an einer zahl ein punkt oder ein f F dann ist das double oder halt mit dem f ein float

#define NUMBER 4711
const int NUMBER = 4711;

Soll das wirkilich identisch sein?

Beim const int sieht der Compiler ein Symbol NUMBER, welches er (wegen dem const) bei jedem Auftauchen durch seinen Wert 4711 ersetzen darf (aber IMO nicht muss). Ein Unterschied ist z.B., dass man hier mit &NUMBER eine Adresse nehmen kann.

Wo liegt dann genau der Unterschied zwischen diesen zwei Zeilen:

#define NUMBER 4711
const int NUMBER = 4711;

Soll das wirkilich identisch sein?

Der Unterschied kommt erst richtig zur Geltung, wenn man sowas hat:

#define A 15
#define B 21
#define C (A + B)

doSomething(C); //wird  doSomething((15 + 21))

//-------

const int A = 15;
const int B = 21;
const int C = A + B; //wird zu 36

doSomething(C);

float ultimateAnswer = 42;

Na? Es spielt keine Rolle, da der Compiler schlau ist und die Variable mit 42 als float belegt. Noch ne Gegenfrage: Von welchem Typ sind 234, 1, 6 oder 13? Sind sie natuerliche Zahlen, ganze, gebrochene, reele oder gar komplexe? Sie sind alles! Deswegen ist die Frage nach dem Typ von Zahlen eine schlecht gestellte Frage. Variablen haben Typen, Zahlen im allgemeinen nicht.

Gegenfrage: Von welchem Typ ist 42 hier:

float ultimateAnswer = 42;

Na? Es spielt keine Rolle, da der Compiler schlau ist und die Variable mit 42 als float belegt.

Und mit einem int initialisiert.

knivil schrieb:

Noch ne Gegenfrage: Von welchem Typ sind 234, 1, 6 oder 13?

int, und nichts anderes.

knivil schrieb:

Sind sie natuerliche Zahlen, ganze, gebrochene, reele oder gar komplexe? Sie sind alles! Deswegen ist die Frage nach dem Typ von Zahlen eine schlecht gestellte Frage. Variablen haben Typen, Zahlen im allgemeinen nicht.

Doch, Zahlen haben unter C++ einen Typ, weswegen man auch Teilweise mit Typkürzeln arbeitet (z.B. 4ul für eine 4 des Types unsigned long...).

Doch, Zahlen haben unter C++ einen Typ, weswegen man auch Teilweise mit Typkürzeln arbeitet (z.B. 4ul für eine 4 des Types unsigned long...).

Da gebe ich den Typ expliziet an. Trotzdem ist es eine schlecht gestellte Frage, da der Compiler ueber die Verwendung der Zahl den Typ ableitet.

Trotzdem ist es eine schlecht gestellte Frage, da der Compiler ueber die Verwendung der Zahl den Typ ableitet.

void f(int);
void f(double);
void f(char);

int main() {
  f(42);
}

...

@knivil:
Schau Dir mal Kapitel 2.13 im C++-Standard an. Da steht ziemlich genau, welche Literale welchen Typen haben.

da der Compiler ueber die Verwendung der Zahl den Typ ableitet.

Tut er nicht. Sonst ergäbe float pi = 42 / 1337 * 100; nicht 0.

Noch ne Gegenfrage: Von welchem Typ sind 234, 1, 6 oder 13? Sind sie natuerliche Zahlen, ganze, gebrochene, reele oder gar komplexe? Sie sind alles! Deswegen ist die Frage nach dem Typ von Zahlen eine schlecht gestellte Frage. Variablen haben Typen, Zahlen im allgemeinen nicht.

Falsch, falsch, falsch!

void function(int value);
void function(short value);
void function(unsigned int value);

...

int main()
{
    function(25);
}

Na, welche Funktion wird hier wohl aufgerufen?
Antwort: Die mit int.
Weil eine Zahl, die keinem Typ zugewiesen ist, per default ein int ist und nicht "alles".
Booyashaka!

[...]Weil eine Zahl, die keinem Typ zugewiesen ist, per default ein int ist und nicht "alles".[...]

Das stimmt auch nicht.
Was wird z.B. hierbei aufgerufen:

function(42.0);

Dabei hat die Zahl auch keinen Typen "zugewiesen", und trotzdem ist es kein int.

Edit: komische Schreibfehler und eigene Blödheit

Das hat die Zahl auch keinen Typen "zugewiesen", und trotzdem ist es kein int.

Ich bin mir gerade nicht sicher ob 42.0 double oder float, glaube aber ersteres ist.

I know it better schrieb:

[...]Weil eine Zahl, die keinem Typ zugewiesen ist, per default ein int ist und nicht "alles".[...]

Das stimmt auch nicht.

[...]Weil eine literale Zahl, die ohne Angabe eines Dezimalpunkts notiert ist, ohne Typpostfix automatisch ein int ist.

(Der Passus "keinem Typ zugewiesen" ist so auch mißverständlich. Durch die Zuweisung an eine Variable vom Typ != int ändert sich nämlich der Typ des Literals nicht)

Wo liegt dann genau der Unterschied zwischen diesen zwei Zeilen:

#define NUMBER 4711
const int NUMBER = 4711;

Soll das wirkilich identisch sein?

Ein möglicher Unterschied ist folgendes (vorsicht, das Makro-Gefrickel wird nicht für zu Hause empfohlen ;))

#define NUMBER 4711

double foo4711();
double foo4712();

void bar()
{
  int i = NUMBER; //okay, das ginge auch mit const int NUMBER...
  float f = 0.34##NUMBER##f; //0.344711f !!
  double d = foo##NUMBER##(); //Aufruf von foo4711() 
}

Soll heißen: Makros sind wirklich nur reine Textersetzung die man sogar als Teilstrings von Variablennamen benutzen kann. Der Compiler sieht nichts davon, deshalb kannst du bei Makros auf Typsicherheit und sinnvolle Fehlermeldungen nicht zählen - einer der Hauptgründe weshalb sie soweit möglich gemieden werden.

Beim #define sieht der Compiler von NUMBER nichts mehr. Der Compiler sieht, überall wo vor dem Präprozessorlauf NUMBER stand, nun ein Integerliteral mit dem Wert 4711.

Beim const int sieht der Compiler ein Symbol NUMBER, welches er (wegen dem const) bei jedem Auftauchen durch seinen Wert 4711 ersetzen darf (aber IMO nicht muss). Ein Unterschied ist z.B., dass man hier mit &NUMBER eine Adresse nehmen kann.

Danke, dass war mein Problem. Der Compiler sieht nur noch 4711, was er als int interpretiert - was in meinem Beispiel auch richtig ist.

Mit einem Postfix f

#define NUMBER 4711f

könnte ich den Typ float erzwingen oder einen implizieten cast vornehmen

#define NUMBER 4711
void doSomething( float fNumber);
doSomething( NUMBER );
doSomething( 4711 );

Nun ist mir klar, wie der Compiler den Typ herausfindet.

Soll heißen: Makros sind wirklich nur reine Textersetzung die man sogar als Teilstrings von Variablennamen benutzen kann. Der Compiler sieht nichts davon, deshalb kannst du bei Makros auf Typsicherheit und sinnvolle Fehlermeldungen nicht zählen - einer der Hauptgründe weshalb sie soweit möglich gemieden werden.

Stimmt, wenn ich in einem Software-Team arbeiten würde, welches auf Typsicherheit wert legen würde.

Die Realität sieht leider anders aus.

knivil schrieb:

Gegenfrage: Von welchem Typ ist 42 hier:

float ultimateAnswer = 42;

Na? Es spielt keine Rolle, da der Compiler schlau ist und die Variable mit 42 als float belegt. Noch ne Gegenfrage: Von welchem Typ sind 234, 1, 6 oder 13? Sind sie natuerliche Zahlen, ganze, gebrochene, reele oder gar komplexe? Sie sind alles! Deswegen ist die Frage nach dem Typ von Zahlen eine schlecht gestellte Frage. Variablen haben Typen, Zahlen im allgemeinen nicht.

enum Type
{
  NUMBER,
  TEXT,
  IMAGE,
  FILE
};

Tjo, das gibt einen äusserst seltsamen Kompilerfehler. Dem Präprozessor sind Scopes scheiss egal.

Und auch einen weit bekannten blöder Fehler, ist der folgende:

#include <windows.h>
#include <limits>

int main()
{
  std::numeric_limits<int>::max();

  return 0;
}

max ist ein Makro in windows.h , was zu einem Fehler führt in diesem Code.

Übrigens, die integer und floating point Literale sind im Standard so definiert, dass der Compiler eine freie Wahl, mit den folgenden Regeln:

Sufix              Decimal constant             Octal or hexadecimal constant
-------------------------------------------------------------------------------
none               int                          int
                   long int                     unsigned int
                                                long int
                                                unsigned long int
-------------------------------------------------------------------------------
u or U             unsigned int                 unsigned int
                   unsigned long int            unsigned long int
-------------------------------------------------------------------------------
l or L             long int                     long int
                                                unsigned long int
-------------------------------------------------------------------------------
Both u or U        unsigned long int            unsigned long int
and l or L         
-------------------------------------------------------------------------------

Floating Point:
1.
.0
1e1
1.e2
1.0e3
sind alles doubles.

Für float braucht es das Suffix f oder F:
1.f
.0f
1e1f
1.e2f
1.0e3f

Für long double braucht es das Suffix l oder L:
1.l
.0l
1e1l
1.e2l
1.0e3l

Ich hoffe ich habe jetzt nichts falsch abgeschrieben

Grüssli

Stimmt, wenn ich in einem Software-Team arbeiten würde, welches auf Typsicherheit wert legen würde.

Die Realität sieht leider anders aus.

Was nicht bedeuten muss dass du es ihnen nachmachen und auf Typsicherheit verzichten musst.