Hi,
ich habe gerade etwas über Macros gelesen und bin mir nicht sicher, was für einen Sinn die denn in C++ haben.
Warum sollte ich ein Macro schreiben, wenn ich das auch einfach als normalen Code schreiben könnte?
Ich weis, dass es etwas mit dem Prärozessor zu tun hat und der Art- und Weise wie dieser etwas übersetzt, verstehe aber nicht wirklich den Sinn und wann man Macros anwendet.

Makros sind in C++ nur für Include-Guards und bedingte Kompilation gut.

Include-Guard:

#ifndef FOO_HEADER
#define FOO_HEADER

// Declarations

#endif

Bedingte Kompilation:

#ifdef WIN32
// Compile this code only on Windows machines
#endif

#define REGISTER_MAKRO(function, name) \
        Register(function, SomeTemplate::MyTemplate<function>, name)

Wüsste nicht, wie man das ohne Makro lösen sollte.

Manche Makros lassen sich nicht als normaler code, d.h. eine Funktion schreiben, z.B. wenn das Makro ein Template beinhaltet.

#define REGISTER_MAKRO(function, name) \
        Register(function, SomeTemplate::MyTemplate<function>, name)

Wüsste nicht, wie man das ohne Makro lösen sollte.

Das ist ein häßlicher, unnötiger und unsicherer Hack. Sowas gehört verboten.

Deine hervorragenden Argumente sind zugegebenermaßen kaum zu widerlegen.

Makros sind reine Text-Substitution. Statt dieses dämliche Makro zu nutzen kannst du gleich den Code hinschreiben.

manchmal braucht man automatisch generierte unterschiedliche bezeichner, da nimmt man manchmal __count__ oder __line__ und makros.

manchmal braucht man bezeichner und den bezeichner als string, zum beispiel für factories.

oder auch zum testen

#include <iostream>
using namespace std;

#define SHOW(name) cout<<#name<<" = "<<(name)<<'\n';

int main(){
	int x=5;
	int y=7/x;
	double z=y*x;
	SHOW(x);
	SHOW(y);
	SHOW(x==y);
}

Ausgabe

x = 5
y = 1
x==y = 0

und natürlich für assert und konsorten.

abgesehen vom genannten, wobei das von Kleiner Troll auch ohne makro geht

Hm? Meinst du einfach austippen? Ja, geht. Oder hast du eine andere Lösung im Kopf?

volkard schrieb:

abgesehen vom genannten, wobei das von Kleiner Troll auch ohne makro geht

Hm? Meinst du einfach austippen? Ja, geht. Oder hast du eine andere Lösung im Kopf?

Was spricht gegen:

template<typename Function, typename T>
void Register(Function function, T const& name) {
  Register_helper(function, SomeTemplate::MyTemplate<Function>, name);
}

wobei mir hier der Sinn komplett unklar ist.

oder meintest du statt

#define REGISTER_MAKRO(function, name) \
        Register(function, SomeTemplate::MyTemplate<function>, name)

doch

#define REGISTER_MAKRO(function, name) \
        Register(#function, SomeTemplate::MyTemplate<function>(), name)

??

volkard schrieb:

abgesehen vom genannten, wobei das von Kleiner Troll auch ohne makro geht

Hm? Meinst du einfach austippen? Ja, geht. Oder hast du eine andere Lösung im Kopf?

Du hast nicht klargemacht, was

Register(function,SomeTemplate::MyTemplate<function>,name);

tun soll.
Aber so frißt es mein Compiler nicht, fürchte ich. Der zweite Parameter scheint nur ein Typ zu sein.

template <CommandID ID>
struct CommandID2Type
{
  typedef EmptyType type;
};

#define MAPCOMMANDID(id, mappedtype) \
                                     \
template <>                          \
struct CommandID2Type<id>            \
{                                    \
  typedef mappedtype type;           \
}

MAPCOMMANDID(ERROR, std::string);
MAPCOMMANDID(OUTPUT, std::string);
MAPCOMMANDID(PLAYER_INFO_OPEN, std::vector<OpenPlayerInfo>);
MAPCOMMANDID(TABLE_INFO, TableInfo);
MAPCOMMANDID(TURN_INFO, TurnInfo);

MAPCOMMANDID(PLAY_CARD, CardID);
MAPCOMMANDID(SETUP_PLAYERS, std::vector<std::string>);
#undef MAPCOMMANDID

jedesmal das stuct komplett auszuschreiben wäre doch ein wenig länglich, so sieht man sofort was passiert, und die Wirkunsweise ist dank #undef begrenzt.

Mein Standpunkt ist, dass man Makros mit Vorsicht behandeln sollte, weil es sehr leicht ist, damit zu verschleiern, was eigentlich passiert, wodurch der Code sehr unübersichtlich werden kann, es allerdings Zusammenhänge gibt, in denen Makros schlimmeres verhindern - beispielsweise, den selben Kram zwanzigtausendmal zu schreiben, etwa, wenn dieser sich nicht in eine Funktion auslagern lässt. Das muss dann im Einzelfall entschieden werden.

Konkretes Beispiel: Man schreibt ein C-API um eine C++-Kernbibliothek. Das C-API kennt keine Exceptions, also müssen die vorher abgefangen werden, und häufig in einem solchen Fall auf die gleiche Art und Weise. Da catch-Blöcke sich nicht in Funktionen auslagern lassen, besteht die Wahl bei einem ausreichend großen API dazwischen, die selben zehn oder so Zeilen in jeder Funktion wieder zu copy&pasten oder ein Makro zu schreiben - in so einem Zusammenhang ist ein Makro meines Erachtens nach durchaus vertretbar. Ich berufe mich hier auf das DRY-Prinzip.

Ansonsten gibt es gelegentlich zwischen verschiedenen Compilern Unterschiede in der...ich nenne es mal Auslegung von Standards, für die von Janjan genannten Feature-Makros nicht ausreichen (bzw. bei denen die Umsetzung mit nur diesen Feature-Makros eher unschön ist). Etwa benutze ich für TR1-Header folgendes Konstrukt:

#ifdef __GNUC__
#  define TR1_HEADER(header) <tr1/header>
#else
#  define TR1_HEADER(header) <header>
#endif

#include TR1_HEADER(memory)
#include TR1_HEADER(functional)
// ...

#undef TR1_HEADER

Ansonsten kann ich volkard nur zustimmen. Grundlegend ist das relevante Entscheidungskriterium Übersichtlichkeit. Wenn ich zwei Möglichkeiten zur Auswahl habe, von denen eine übersichtlich und eine unübersichtlich ist, nehme ich die unübersichtliche, völlig egal, welche Sprachmittel ich dazu benutzen muss.

Zu Shade of Mine:

function, SomeTemplate::MyTemplate<Function>, name

und

function, SomeTemplate::MyTemplate<function>, name

Ist nicht dasselbe

Ansonsten kann ich volkard nur zustimmen. Grundlegend ist das relevante Entscheidungskriterium Übersichtlichkeit. Wenn ich zwei Möglichkeiten zur Auswahl habe, von denen eine übersichtlich und eine unübersichtlich ist, nehme ich die unübersichtliche, völlig egal, welche Sprachmittel ich dazu benutzen muss.

Das ehrt Dich. Aber ich bin um ehrlich zu sein, nicht so fleißig und nehme gelegentlich einfach die übersichtlichere.

function ist ein Funktionszeiger mit einer gewissen signatur a, name ist ein std::string, das template hat eine signatur b != a (der einzige Zweck des templates ist genaugenommen die Signatur zu ändern)
Register nimmt nimmt einen Funktionszeiger mit Signatur a, einen mit b, und einen Namen, unter dem es die Funktion unter diesem Namen als callback an 2 voneinander unabhängigen Stellen registriert.

Soll Register auch ein Makro sein? Falls ja, war Dein Posting ein schwaches Argument.
Fall nein, zeige eine einfache Beispielimplementierung für Register.
So glaube ich noch nicht, daß die Anforderung möglich war.

Im echten Beispiel sind "SignaturEins/Zwei" einfach typedefs für einen Funktionszeiger.
Ich hoffe du hast nichts dagegen das ich die Namen etwas generalisiert habe.

template<SignaturEins T> int MyTemplate(int Zahl)
{
std::vector<int> tmp;
tmp.push_back(Zahl);
return T(tmp);
}

#include <vector>
#include <string>

using namespace std;

typedef int (*SigEins)(vector<int>);
typedef int (*SigZwei)(int);

template<SigEins T> int MyTemplate(int Zahl)
{
   vector<int> tmp;
   tmp.push_back(Zahl);
   return T(tmp);
}

int Register(SigEins func, const string& name)
{
   //hier gehts weiter zum registrieren in die eine Richtung, wies genau geht sollte irrelevant sein
   return 0; //wir gehen davon aus das das registrieren hier erfolgreich war
   //return -1; //das wird zurückgegeben falls es nicht erfolgreich war
}

int Register(SigZwei func, const string& name)
{
   //hier gehts weiter zum registrieren in die andere Richtung, wies genau geht sollte irrelevant sein
   return 0;
}

int Register(SigEins function, SigZwei cFunction, const string& name)
{
    if (Register(function, name) != -1)    {
        Register(cFunction, name);
        return 0;
    } else {
        return -1;
    }
}

int Test(vector<int>)
{
   return 2;
}

#define REGISTER_MAKRO(function, name) \
        Register(function, MyTemplate<function>, name)

//alles oberhalb unveränder, außer das makro runtergezogen zum besser 
//anschauen können, während ich das template zusammenfrickle. 

template<SigEins FUNC>
void REGISTER_TEMPLATE(const string& name){
	Register(FUNC,MyTemplate<FUNC>,name);
}

int main()
{
   REGISTER_MAKRO(&Test, "test");
   REGISTER_TEMPLATE<&Test>("test");
}

Wenn die function auch andere Signaturen als SigEins haben können soll, wird der Aufruf in der main aber schon häßlicher. Da mache ich mich dann aber auch locker und denke an Makros.

Aber spaßig wird's mit

#define REGISTER_MAKRO2(function) \
        Register(function, MyTemplate<function>, #function)

int main()
{
   REGISTER_MAKRO(&Test, "test");
   REGISTER_TEMPLATE<&Test>("test");
   REGISTER_MAKRO2(Test);
}