gibt es ein Tool welches die Template Parameter ersetzt?

Also welches aus

template<class T> void swap( T &a , T &b )
{
 T tmp = a; a = b; b = tmp;
};

double a=10.0 , b=20.0;
swap( a , b )

den C++ Code

swap( double &a , double &b )
{
 double tmp = a ; a = b ; b = tmp;
}

ausgibt?

Viele Grüsse

Grüssli

Oder willst du sowas selbst parsen und ersetzen?

Ich kenne kein Tool, dass dies macht, aber ich würde gerne eine Frage aus Neugier stellen: Wieso willst du sowas tun?

Grüssli

Es gibt einige Compiler für embbed Systeme, die kommen mit templates nicht klar. Man könnte beispielsweise mit solch einem Tool oft benutzte Container (z.B. vector<double>) relativ einfach ersetzen...

Es gibt einige Compiler für embbed Systeme, die kommen mit templates nicht klar.

In so einem Fall würde ich mir Comeau C++ mal ansehen.

headmyshoulder schrieb:

Es gibt einige Compiler für embbed Systeme, die kommen mit templates nicht klar.

In so einem Fall würde ich mir Comeau C++ mal ansehen.

Die Entscheidung was für ein Compiler benutzt wird, liegt leider nicht bei mir.

Hast du schon mal auf www.sf.net gesucht? Da findet man zum Teil ganz sonderbare Tools, also wieso auch nicht sowas

Grüssli

ich habs ma bissl quick and dirty angefangen - vll hat ja wer lust, die todos noch zu machen ;o) fehler sollten aber eigtl keine mehr drin sein - habs aber au nich wirklich getestet ^^

#include <iostream>
#include <string>

typedef std::string::size_type str_size_t;
const str_size_t str_npos = std::string::npos;

void replace_template (std::string &fkt, const std::string &tmpl_data_type) //TODO -> 2. parameter=>std::vector <std::string> für mehrere template-parameter
{
	str_size_t pos = fkt.find("template");
	if (pos == str_npos)
		return;

	str_size_t pos2 = fkt.find_first_of ('<', pos);
	if (pos2 == str_npos)
		return;

//TODO: zwischen pos und pos2 dürfen nur leerraumzeichen sein

	str_size_t varaible_type_name_from = fkt.find ("typename ", pos2); //TODO auch "class " ist möglich
	if (varaible_type_name_from == str_npos)
		return;
	varaible_type_name_from += strlen("typename ");
//TODO bis zu '>' parsen -> std::vector varaible_type_names
//TODO: das template <...> zeugs am anfang löschen...

	static const std::string values_to_use_in_name = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ_123456789"; //TODO: iwie noch sicherstellen, dass die zahlen nich am anfang stehen...
	str_size_t varaible_type_name_to = fkt.find_first_not_of (values_to_use_in_name, varaible_type_name_from);
	if (varaible_type_name_to == str_npos)
		return;

	const std::string varaible_type_name = fkt.substr(varaible_type_name_from, varaible_type_name_to - varaible_type_name_from);

	str_size_t act_pos = fkt.find (varaible_type_name, varaible_type_name_to +1);
	while (act_pos != str_npos)
	{
		if (values_to_use_in_name.find (fkt[act_pos-1]) != str_npos)
		{
			act_pos = fkt.find (varaible_type_name, act_pos+1);
			continue;
		}
		if(act_pos+varaible_type_name.length() >= fkt.length())
		{
			break;
		}
		if (values_to_use_in_name.find (fkt[act_pos+varaible_type_name.length()]) != str_npos)
		{
			act_pos = fkt.find (varaible_type_name, act_pos+1);
			continue;
		}

		fkt.replace (act_pos, varaible_type_name.length(), tmpl_data_type);
		act_pos += tmpl_data_type.length();
		act_pos = fkt.find (varaible_type_name, act_pos);
	}
}

int main()
{
	std::string fkt = "template<typename T> void swap( T &a , T &b ) { T tmp = a; a = b; b = tmp; }";
	replace_template (fkt, "int");

	std::cout << fkt << std::endl;
}

dann könnte (sollte) man die fkt noch ein wenig mehr aufsplitten - dann sieht man vll nicht nur durch, sondern es würde vll auch irgendwann noch relativ wenig arbeit sein, die versch. template-parameter zu ersetzen etc...

allerdings müsstest du jz noch alle files vorm compilieren parsen, gucken, mit welchem typ du instanzierst und dann das template an sich auskommentieren (#if 0; #endif), dann die fkt generieren und die generierten fkt einfügen, dann compilieren lassen und dann deine änderungen wieder rückgängig machen... x)

bb

ps: vll hab ich samstag (eher sonntag ^^) noch mal lust, und versuch mich ma noch ma dran ^^

allerdings müsstest du jz noch alle files vorm compilieren parsen, gucken, mit welchem typ du instanzierst und dann das template an sich auskommentieren (#if 0; #endif), dann die fkt generieren und die generierten fkt einfügen, dann compilieren lassen und dann deine änderungen wieder rückgängig machen... x)

ROFLMAO ...
Und in 200 Jahren ist er dann fertig?

Grüssli

unskilled schrieb:

allerdings müsstest du jz noch alle files vorm compilieren parsen, gucken, mit welchem typ du instanzierst und dann das template an sich auskommentieren (#if 0; #endif), dann die fkt generieren und die generierten fkt einfügen, dann compilieren lassen und dann deine änderungen wieder rückgängig machen... x)

ROFLMAO ...
Und in 200 Jahren ist er dann fertig?

deshalb auch das smilie: x)

naja - so extrem schwer sollte das aber auch nich zu schreiben sein...

ich habs ma bissl quick and dirty angefangen - vll hat ja wer lust, die todos noch zu machen ;o) fehler sollten aber eigtl keine mehr drin sein - habs aber au nich wirklich getestet ^^

Naja, ich glaub so einfach geht das auch nicht, ich kann mir zumindest nicht vorstellen, dass damit die vector Klassen erzeugt werden können. Die haben ja default parameter und das allocator Objekt. Für einfache Sachen wäre das eine Lösung.

a) die Arbeit des Präprozessors mitmacht (vor allem #includes)
b) sich jede templatedefinition merkt
c) bei jeder instantiierung eines Templates den entsprechenden Code erzeugt
d) eine Typtabelle für alle Variablen (auch die temporären!) im aktuell geparsten Scope führt, um die Templateparameter von Funktionstemplates herleiten zu können

Der erzeugte "template-Ersatzcode" müsste dann in einen anonymen Namespace verfrachtet werden bzw in header und source aufgeteilt werden um nicht die ODR zu verletzen (z.B. wenn in zwei TUs swap<int> aufgerufen wird)

bb

edit:
zum odr: naja - das ist ja rel. einfach mit inline zu umgehen ^^

edit:
zum odr: naja - das ist ja rel. einfach mit inline zu umgehen ^^

Kann man Typen auch inline machen?
Ich denke, dass wäre noch ein ziemlich grosses Projekt. Da fragt man sich fast, ob man einen Umweg über Assembler machen könnte. Also mit einem anderen Kompiler übersetzen und dann den generierten Assembler Code in die Assemblersprache für den anderen Chipsatz übersetzen. Könnte womöglich einfacher sein

Grüssli

...In so einem Fall würde ich mir Comeau C++ mal ansehen.

Oha ...

Breathtaking ...
Amazing ...
Fabulous ...

Das kann doch nur Satire sein, oder?.... (also die Formulierung nicht das Produkt)

@Topic: Wobei ich mir das auch schon öfter mal gewünscht hätte - nur interessehalber. Einfach mal sehen, was ein Compiler so "intern" aus templates macht.

Die Instantiierung ist ja schon ein Prozess, der ein wenig "vorab" läuft und dessen Ergebnisse oftmals mit "normalen C++-Elementen" erklärt werden.
Es gibt allerdings auch Sachen wie z.B. der Vorzug von "normalen Funktionen" ggü. template-Instanzen, bei denen die template-Herkunft durchaus noch eine Rolle spielt.

Gruß,

Simon2.

Das kann doch nur Satire sein, oder?.... (also die Formulierung nicht das Produkt)

Das Produkt jedenfalls nicht; das ist so ziemlich der konformste C++-Compiler, den es gibt (dank dem EDG-Frontend). Du kannst ihn online testen: http://www.comeaucomputing.com/tryitout/

Aber was die Produktwerbung angeht, die ist in der Tat eigenwillig.

Comeau Computing schrieb:

Bursting With So Much Language Support It Hurts!

unskilled schrieb:

edit:
zum odr: naja - das ist ja rel. einfach mit inline zu umgehen ^^

Kann man Typen auch inline machen?

ach verdammt

Das kann doch nur Satire sein, oder?.... (also die Formulierung nicht das Produkt)

Was ich auch nahezu liebe, ist das sehr moderne und übersichtliche Design der Seite. Natürlich nach dem unten blinkenden "Order Now!"-Balken.

Simon2 schrieb:

Das kann doch nur Satire sein, oder?.... (also die Formulierung nicht das Produkt)

Was ich auch nahezu liebe, ist das sehr moderne und übersichtliche Design der Seite. Natürlich nach dem unten blinkenden "Order Now!"-Balken.

Hehe.. Sehe ich auch so.. - Aber wer so ein gutes Produkt hat, kann sich so etwas ja schon leisten.