float per void* an funktion uebergeben

[nebo]

warum darf man das hier nicht machen?

void test(void *ptr)
{
	std::cout << (float)ptr << std::endl;
}

int main()
{
	float i = 3.4;
	test(&i);
}

[nebo]

sollte wohl so gehn:

std::cout << *(Float32*)ptr << std::endl;

wie mach ich da noch einen cast in int oder so?

[C++ Forumbot]

Dieser Thread wurde von Moderator/in c.rackwitz aus dem Forum ANSI C in das Forum C++ verschoben.

Im Zweifelsfall bitte auch folgende Hinweise beachten:
C/C++ Forum :: FAQ - Sonstiges :: Wohin mit meiner Frage?

Dieses Posting wurde automatisch erzeugt.

[nebo]

void Convert(void *pFrom, void *pTo)
{
	float *ptr = (float*)pFrom;
	*(int*)pTo = (int)*ptr;
}

int main()
{
    float i = 3.4;
	int j = 0;
    Convert(&i, &j);
	std::cout << j << std::endl;

	return 0;
}

ich will 2 void pointer uebergeben und in der funktion zb von float in int casten...kann ich das vielleicht noch etwas schöner schreiben?

[nebo]

so gehts auch...kann man hier die klammern noch schöner setzen?

void Convert(void *pFrom, void *pTo)
{
	*(int*)pTo = (int)*(float*)pFrom;
}

die funktion soll später verschiedene typen konvertieren....deshalb der void* es kommen noch 2 param dazu später....dataTypeFrom u dataTypeTo....

cu

[nebo]

sowas in der art....ist c code!!

enum MultiType
{
	Integer,
	Float,
    Double,
    Character,
    Boolean
};

void Convert(MultiType tFrom, void *pFrom, MultiType tTo, void *pTo)
{
	switch(tFrom)
	{
		case Integer:
			switch(tTo)
			{
				case Integer:
					*(int*)pTo = *(int*)pFrom;
					break;

				case Double:
					*(double*)pTo = (double)*(int*)pFrom;
					break;

				case Character:
					*(char*)pTo = (char)*(int*)pFrom;
					break;

				case Boolean:
					*(bool*)pTo = (bool)*(int*)pFrom;
					break;
			}

		case Float:
			switch(tTo)
			{
				case Integer:
					*(int*)pTo = (int)*(float*)pFrom;
					break;

				case Double:
					*(double*)pTo = (double)*(float*)pFrom;
					break;

				case Character:
					*(char*)pTo = (char)*(float*)pFrom;
					break;

				case Boolean:
					*(bool*)pTo = (bool)*(float*)pFrom;
					break;
			}

		case Double:
			switch(tTo)
			{
				case Integer:
					*(int*)pTo = (int)*(double*)pFrom;
					break;

				case Double:
					*(double*)pTo = (double)*(double*)pFrom;
					break;

				case Character:
					*(char*)pTo = (char)*(double*)pFrom;
					break;

				case Boolean:
					*(bool*)pTo = (bool)*(double*)pFrom;
					break;
			}

		case Character:
			switch(tTo)
			{
				case Integer:
					*(int*)pTo = (int)*(char*)pFrom;
					break;

				case Double:
					*(double*)pTo = (double)*(char*)pFrom;
					break;

				case Character:
					*(char*)pTo = *(char*)pFrom;
					break;

				case Boolean:
					*(bool*)pTo = (bool)*(char*)pFrom;
					break;
			}

		case Boolean:
			switch(tTo)
			{
				case Integer:
					*(int*)pTo = (int)*(bool*)pFrom;
					break;

				case Double:
					*(double*)pTo = (double)*(bool*)pFrom;
					break;

				case Character:
					*(char*)pTo = (char)*(bool*)pFrom;
					break;

				case Boolean:
					*(bool*)pTo = *(bool*)pFrom;
					break;
			}
	}
}

int main()
{
    float i = 3.4;
	int j = 0;
	Convert(MultiType::Float, &i, MultiType::Integer, &j);
	std::cout << j << std::endl;

	return 0;
}

[bluecode]

Darf man fragen was du machen willst? btw. benutz lieber c++ casts... da kann man sich etwas sicherer sein, was denn überhaupt gemacht wird Generell würd ich mir mal generische Programmierung/Metaprogrammierung bzw. Templates anschaun.