ich habe probs mit der konvertierung von float in float *.

int CGamma::GetGamma(float *fGammaRed,float *fGammaGreen,float *fGammaBlue)
{
	fGammaRed = ((float)GammaNow[0]-(float)0.5)*(float)2;
	fGammaGreen = ((float)GammaNow[1]-(float)0.5)*(float)2;
	fGammaBlue = ((float)GammaNow[2]-(float)0.5)*(float)2;
	return 1;
}

thx thx!

War doch garnicht so schwer

int CGamma::GetGamma(float *fGammaRed,float *fGammaGreen,float *fGammaBlue)
{
	fGammaRed = (float*) ((float)GammaNow[0]-(float)0.5)*(float)2;
	fGammaGreen = (float*) ((float)GammaNow[1]-(float)0.5)*(float)2;
	fGammaBlue = (float*) ((float)GammaNow[2]-(float)0.5)*(float)2;
	return 1;
}

thx.

int CGamma::GetGamma(float *fGammaRed,float *fGammaGreen,float fGammaBlue)
{
fGammaRed = static_cast <float> (((float)GammaNow[0]-(float)0.5)(float)2);
fGammaGreen = static_cast <float> (((float)GammaNow[1]-(float)0.5)(float)2);
fGammaBlue = static_cast <float> (((float)GammaNow[2]-(float)0.5)*(float)2);
return 1;
}

int CGamma::GetGamma(float *fGammaRed,float *fGammaGreen,float *fGammaBlue) 
{ 
fGammaRed = static_cast <float*> (((float)GammaNow[0]-(float)0.5)*(float)2); 
fGammaGreen = static_cast <float*> (((float)GammaNow[1]-(float)0.5)*(float)2); 
fGammaBlue = static_cast <float*> (((float)GammaNow[2]-(float)0.5)*(float)2); 
return 1; 
}

Dann halt so 

int CGamma::GetGamma(float *fGammaRed,float *fGammaGreen,float *fGammaBlue) 
{ 
*fGammaRed = static_cast <float*> (((float)GammaNow[0]-(float)0.5)*(float)2); 
*fGammaGreen = static_cast <float*> (((float)GammaNow[1]-(float)0.5)*(float)2); 
*fGammaBlue = static_cast <float*> (((float)GammaNow[2]-(float)0.5)*(float)2); 
return 1; 
}

...

was heißt überhaupt dereferieren?

Es war die Rede von "dereferenzieren", und bedeutet, dass man den auf den Inhalt der Speicheradresse, auf die der Zeiger zeigt, zugreift.

es geht hier um c++.

Du weist wohl selber nicht, worum es hier geht! Erstens postest du deine Frage ins verkehrte Subforum (hat mit WinAPI wirklich nen Scheißdreck zu tun!), und zweitens ist das C Code, der in deiner Frage steht. Anstatt Zeiger nimmt man Referenzen, und anstatt C-Casts C++ Casts alla static_cast. Und jetzt redest du plötzlich von C++ -.- Junge, verdammt nochmal, setz dich an ein Tutorial, und lass die Finger von solchen Spielereien wie dein Ärgerei-Tool!

was jetz schon penn?
ich glaub mein schwein pfeift...
wie sieht das denn jetzt aus? bei mir funzts net.
also??@helpa-möchtegern

was jetz schon penn?

Was sagen deine Eltern dazu?

ich glaub mein schwein pfeift...

Und du pfeifst aus dem letzten Loch, geh schlafen.

wie sieht das denn jetzt aus? bei mir funzts net.

Dann lies dir nen Tut durch, und ersetze deinen C Code mal durch C++ (pale, schweig!)

also??@helpa-möchtegern

Die Antwort hatte ich dir schon gegeben!

naja trotzdem geh ich net penn. eldern sagen nix.. sind schon im bett .hehe.

ich komm net klar!
was heißt überhaupt dereferieren?
es geht hier um c++.
also könnte jemand mir bidde ein funktionierendes beispiel geben.
dann kapiere ich dat auch.
thx.

(D)Evil schrieb:

void CGamma::get_gamma(float* pfGammaRed, float* pfGammaGreen, float* pfGammaBlue) const
{
    *pfGammaRed = (static_cast<float>(GammaNow[0]) - 0.5f) * 2.0f;
    *pfGammaGreen = (static_cast<float>(GammaNow[1]) - 0.5f) * 2.0f;
    *pfGammaBlue = (static_cast<float>(GammaNow[2]) - 0.5f) * 2.0f;
}

...

Und hör nicht auf helpa, der hat zig Posts verfasst, aber so gut wie jeder war falsch ^^

Von welchem Typ ist GammaNow? Je nach dem brauchst du nicht mal das static_cast

Dereferenzieren heisst vom Zeiger wieder zurück auf das Objekt gehen (Darf man das so sagen? ^^)

int iObject;
int* pPointerOnObject = &iObject;
int iObject2 = *pPointerAufObject; // Der Stern dereferenziert den Zeiger und man hat wieder das Objekt,
// Also anstatt int* ein int und zwar der auf welcher int* verweist. In diesem Beispiel wäre das iObject

Würde dir aber empfehlen den Teil mit den Zeigern nochmals zu lesen oder folgender Artikel:
http://www.c-plusplus.net/forum/viewtopic-var-t-is-124532.html

Edit: Mist, in letzter Zeit bin ich aber wirklich immer zu spät. ^^"

Grüssli

Und hör nicht auf helpa, der hat zig Posts verfasst, aber so gut wie jeder war falsch ^^

Na, einbisschen Leichtsinnigkeit ist doch jedem erlaubt (D)evil seiner war doch auch falsch.

int CGamma::GetGamma(float* fGammaRed,float* fGammaGreen,float* fGammaBlue)
{
	*fGammaRed = (((float)GammaNow[0]-(float)0.5)*(float)2);
	*fGammaGreen = (((float)GammaNow[1]-(float)0.5)*(float)2);
	*fGammaBlue = (((float)GammaNow[2]-(float)0.5)*(float)2);
	return 1;
}

so thx! das funzt.
also wen helpa mich nicht zum tut lesen gebracht hätte, wüsste ich immer noch net, wie das geht...^^thx.

@helpa: naja diese gamma klasse ist nicht nur!! für mein Nervtool geeignet.
man kann damit einfach die Gamma verstellen und das einzeln für die farben.
damit kann man so blink-flashs erzeugen.^^ für mein nervtool. hehe.

@helpa: naja diese gamma klasse ist nicht nur!! für mein Nervtool geeignet.
man kann damit einfach die Gamma verstellen und das einzeln für die farben.
damit kann man so blink-flashs erzeugen.^^ für mein nervtool. hehe.

jaja, blinki blinki. Okay, bei 15 Jahren kann ich das noch nachvollziehen.

...und da es um C und nicht C++ geht, lass mal die static_casts weg, und nimm die vorherige Lösung mit den (float). Die Variablen musst du aber weiterhin dereferenzieren.

... Ja ist klar. Zeig dein Geistiges Niveau und glaub das C objektorientiert ist ... (Klassen ...)

(float)0.5

vollkommen unnötiger, unperformanter cast. Warum nicht direkt 0.5 als Fließkommazahl angeben?

0.5f

...

(float)2

Das er einen Integer nicht ohne weiteres als float ansieht, müsste dir auch klar sein... 0.5 war ja ein double-Wert. Aber korrekt ist auch hier:

2.0f

(float)GammaNow[0]

C-Style-Cast ... vollkommen unschön, wenn du C++ programmieren willst.

float*

C++ kennt Referenzen!

return 1;

Wofür etwas zurückgeben, wenn bei der Funktion nichts schief gehen kann? Also Rückgabewert void.

=>

void CGamma::get_gamma(float& red, float& green, float& blue) const // const, da du keine Membervariablen veränderst!
{
    red = (static_cast<float>(GammaNow[0]) - 0.5f) * 2.0f;
    green = (static_cast<float>(GammaNow[1]) - 0.5f) * 2.0f;
    blue = (static_cast<float>(GammaNow[2]) - 0.5f) * 2.0f;
}

...

Und helpa ... zügel mal ein wenig dein loses Mundwerk... wenn man schon so wenig Ahnung hat.
Script-Styler: nimm nicht alles als bare Münze, was von Gästen in diesem Forum geschrieben wird!