Zu meiner Frage:
Ich hab mehrere define Anweisungen
z.B

#define L1 16
#define L2 12
#define L3 19 usw.

jetzt möchte ich in einer for-schleife die defines durchgehen.
Sprich

for(i=1;i<10;i++)
{wert=Li;}

Li ist L1,L2,L3 usw.
nur wie kann ich das vernünftig schreiben?

Generell sollte man in C++ #defines nur nutzen, wenn sie wirklich nötig sind. Besser sind Konstanten bzw. Arrays:

const int L[] = {16, 12, 19};

Nachher würde da stehen:

for (int i = 0; i < groesse; ++i)
{
    wert = L[i];
}

ich hab natürlich nur für das Beispiel einfache integer Werte verwendet;

in wirklichkeit stehen dahinter recht lange makros die ich nicht in einem array haben kann.

Könntest du mir dann bitte sagen wie man es mit defines machen kann dass sich die bezeichnung dynamisch ändert?

Könntest du mir dann bitte sagen wie man es mit defines machen kann dass sich die bezeichnung dynamisch ändert?

Die Frage ist einfach zu beantworten: Garnicht. Aber evtl. gibt es Alternativen, wenn Du uns mehr Informationen gibst

Könntest du mir dann bitte sagen wie man es mit defines machen kann dass sich die bezeichnung dynamisch ändert?

Ich kann mich nur wiederholen: Das ist eine sehr unsaubere und fehleranfällige Lösung (wie generell die Arbeit mit Makros). Wieso solltest du keine Arrays verwenden können? Du brauchst ja keine verschiedenen Bezeichner mehr, sondern nur ein Array mit mehreren Werten.

...

Schon mal an std::map gedacht?
(Container mit Schlüssel/Wert-Paar)

cu André

Hago10 schrieb:

Könntest du mir dann bitte sagen wie man es mit defines machen kann dass sich die bezeichnung dynamisch ändert?

Die Frage ist einfach zu beantworten: Garnicht.

So pauschal würde ich das nicht beantworten, immerhin gibt es den ##-Operator, mit dem man Quelltext zusammenhängen kann. Aber eben, davon ist abzuraten, std::map scheint eine elegante Lösung zu sein.

Trotzdem verstehe ich momentan nicht, was gegen ein konstantes Array spricht...?

So pauschal würde ich das nicht beantworten, immerhin gibt es den ##-Operator, mit dem man Quelltext zusammenhängen kann.

Grundsätzlich hast Du natürlich recht, aber dafür muss das zusammenzuhängende auch im Quelltext konstant sein. (L##i ergibt höchstens "Li", aber niemals L1, L2, ...)

LordJaxom schrieb:

Hago10 schrieb:

Könntest du mir dann bitte sagen wie man es mit defines machen kann dass sich die bezeichnung dynamisch ändert?

Die Frage ist einfach zu beantworten: Garnicht.

So pauschal würde ich das nicht beantworten, immerhin gibt es den ##-Operator, mit dem man Quelltext zusammenhängen kann. Aber eben, davon ist abzuraten, std::map scheint eine elegante Lösung zu sein.

Nein. Das würde nicht gehen. #define macht lediglich eine Textersetzung. Und die ist bei Laufzeit des Programmes vorbei. Der kennt dann L1 usw. gar nicht mehr. Da steht dann einfach eine 2 usw.

in wirklichkeit stehen dahinter recht lange makros die ich nicht in einem array haben kann.

Das klingt nicht so, dass es wirklich eine gute Idee ist.
Vor allem sollten da keine "Berechnungen" oder ähnliches durchgeführt werden.
Berühmtes Beispiel:

#define m_pow(x) x*x

int pow (int x){
return x*x;
}
...
int z = 2;
std::cout << pow (++z) << std::endl;
int v = 2;
std::cout << m_pow (++v) << std::endl;

Ooops. Das Beispiel erklärt sich von selbst, wenn man bedenkt, dass lediglich eine Textersetzung (zur Compile Zeit) stattfindet.

v = 2;
++v * ++v
2+1 * 3+1
3 * 4 = 12

oder wo liet mein fehler? Oo

In deinem Fall macht der compiler folgendes:

++v;
++v;
v*v;

Nexus schrieb:

So pauschal würde ich das nicht beantworten, immerhin gibt es den ##-Operator, mit dem man Quelltext zusammenhängen kann.

Grundsätzlich hast Du natürlich recht, aber dafür muss das zusammenzuhängende auch im Quelltext konstant sein.

Ist er doch, i geht von 0 bis 10. Mit ein paar Präprozessorhacks (oder Boost.Preprocessor) kann man die Schleife ausrollen.

Und wenn nur eine Grenze unklar ist, dann rollt man sich das ganze halt zu einem switch aus:

switch (n)
{
case 100: L100;
…
case 1: L1;
case 0: L0;
};

bzw. andersrum für eine veränderliche untere Grenze.

LordJaxom schrieb:

Nexus schrieb:

So pauschal würde ich das nicht beantworten, immerhin gibt es den ##-Operator, mit dem man Quelltext zusammenhängen kann.

Grundsätzlich hast Du natürlich recht, aber dafür muss das zusammenzuhängende auch im Quelltext konstant sein.

Ist er doch, i geht von 0 bis 10. Mit ein paar Präprozessorhacks (oder Boost.Preprocessor) kann man die Schleife ausrollen.

Und wenn nur eine Grenze unklar ist, dann rollt man sich das ganze halt zu einem switch aus:

switch (n)
{
case 100: L100;
…
case 1: L1;
case 0: L0;
};

bzw. andersrum für eine veränderliche untere Grenze.

Dies kann man aber weiteraus besser mit Funktions-Pointer oder dynamischen Objekten loesen.

typedef (*funktion)();

funktion f[] = new funktion[50];
f[0] = funktion1;
f[1] = funktion2;
f[2] = funktion3;
// ...
for (int  i=0; i<50; i++) f[i](); // oh, geht das ueberhaupt?
// so oder so aehnlich wuerde es in C aussehen, fuer C++ bitte std::list
// und dynamische Objekte verwenden

funktion f[] = new funktion[50];

kann es sein dass du etwas zuviel C# programmierst?

Außerdem ist der Code dann da wo er hin gehört und nicht irgendwie über die Übersetzungseinheit verstreut.