es geht um etwa um folgendes: wie schreibe ich ein makro, das sich selbst eine lokale variable erzeugt, dann damit irgendetwas macht, danach etwas zurückgibt, und die lokale variable löscht?

hab da an so was ähnliches gedacht:

#define MY_MACRO(x) {int y=100; return x+y;}

//verwendung:
int i=MY_MACRO(50); //i=150;

//...return funktioniert offensichtlich nur bei funktionen, und nicht bei den einzelnen {}-blöcken :-/

wie zu erwarten war, hats nicht funktioniert...
wisst ihr, wie man so etwas anstellen könnte, ohne eine extra funktion dafür zu schreiben?

weis, ist ne komische, und irgendwie sinnlos aussehende frage, wäre aber für jeden vorschlag dankbar

mfg andrey

int i = MY_MACRO

int i=MY_MACRO

ohne parameter, klammer und semikolons?

inline int Add( int x )
{
 return x + 100;
}

//...

int i = Add( 50 );

Gruß

Edit:
Ah ich glaub ich habs nun verstanden was du meinst:

#define ADD( x ) x + 100

// ...

int i = ADD( 50 );

template< int x >
struct _100plusX
{
	enum { value = x+100 };
};

// ...

int i = _100plusX< 50 >::value;

// ...

grüße

in DX gibts eine struktur D3DCOLORVALUE die aus den angaben der farben und transparenz in float werten besteht ( r,g,b,a )

was ich jetzt wollte: ein makro, das mir aus den vier floats eine D3DCOLORVALUE struktur zusammenbaut, also vier floats annimmt, und eine einzige struktur wieder zurückgibt. dafür wollte ich ein makro schreiben, das zuerst die vier floats in ein array schreibt, aund dann den dereferenzierten pointer auf den array-anfang zurückgibt, in etwa so:

#define D3DCOLORVALUE_RGBA(r,g,b,a) \
{ float array[]={r,g,b,a}; return *((D3DCOLORVALUE*)(array)); }

//nicht funzender "pseudo-code"
//idee: das sollte eine "funktion ohne funktionskopf" werden

ich könnte es natürlich auch einfach als eine funktion definieren:

D3DCOLORVALUE D3DCOLORVALUE_RGBA(r,g,b,a){
  float array[]={r,g,b,a};
  return *((D3DCOLORVALUE*)(array));
}

würde gehen, klar, nur irgendwie habe ich grad keine lust den code mit irgendwelchen irgendwo gloabal definierten funktionen vollzustopfen, oder für diese eine einzige funktion irgendsoeine singletonklasse zu schreiben, oder die an irgendeine andere klasse dranzuhängen, die eigentlich nichts damit zu tun hat... mit anderen worten: ich wills als eine einfache textersetzung haben. ausschlieslich für die einheitlichkeit und übersichtlichkeit, damit ich nirgendwo pseudo-makros stehen hab, die gar keine makros sind.

D3DCOLORVALUE myColor={0.1f, 0.2f, 0.3f, 0.4f}; //klappt
myColor={0.9f, 0.8f, 0.7f, 0.6f}; //klappt nicht mehr

trotzdem allen vielen dank

naja, egal, vergessts leute, ich mach das jetzt einfach doch zu einer globalen funktion, der kleine stilbruch wird schon keine auswirkungen haben...

Eh? Du ziehst ein Makro einer freien Funktion vor?
(Unabhängig davon dass weder Makro noch Funktion noch sonstwas den C++-Standard ändern werden: was du vorhast funktioniert in der Form einfach nicht.)

class ColorValue
{
private:
	float r, g, b, a;

public:
	ColorValue()
	: r( 0 ), g( 0 ), b( 0 ), a( 0 )
	{}

	void operator()( float _r, float _g, float _b, float _a )
	{
		r = _r;
		g = _g;
		b = _b;
		a = _a;
	}

	void Set(  float _r, float _g, float _b, float _a )
	{
		r = _r;
		g = _g;
		b = _b;
		a = _a;
	}

	operator D3DCOLORVALUE()
	{
		return *reinterpret_cast< D3DCOLORVALUE *>( this );
	}
};

Edit:

ne, eine "wrapperklasse" wäre schon echt total overkill wegen einem einzigen blöden makro

Naja, wenn du meinst...

Hi,
was soll der Sinn der Sache sein? Es gibt nicht ohne Grund Funktionen...

Einen Sinn gibt es da durchaus, schließlich ist solch ein Code in anderen Sprachen gang und gäbe, z.B. in Ruby. Hier steuern Blöcke z.B. Funktionen höherer Ordnung:

xs = (1..5)
ys = xs.map {|x| x * 2}
puts ys

Die Ausgabe wäre dann [2, 4, 6, 8, 10] ('map' führt einen Block auf jedes Element eines Arrays aus und gibt das modifizierte Array zurück).

Auch den ternären C++-Operator :? kann man durch den Rückgabewert von Blöcken ersetzen, indem man einfach mit einem Konditional arbeitet: 'y = if (x == 5) then 2 else 3' (Pseudocode). Hier sind '2' und '3' im Prinzip ja Ein-Anweisungs-Blöcke.