float per void* an funktion uebergeben

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);
}

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.

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?

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

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.