Wann sind C ++ - Makros von Vorteil? [geschlossen]

Der C- Präprozessor wird von der C ++ - Community zu Recht gefürchtet und gemieden. Inline-Funktionen, Konstanten und Vorlagen sind normalerweise eine sicherere und überlegene Alternative zu a #define.

Das folgende Makro:

#define SUCCEEDED(hr) ((HRESULT)(hr) >= 0)  

ist dem Typ sicher in keiner Weise überlegen:

inline bool succeeded(int hr) { return hr >= 0; }

Aber Makros haben ihren Platz. Bitte listen Sie die Verwendungszwecke für Makros auf, die Sie ohne den Präprozessor nicht ausführen können.

Bitte geben Sie jeden Anwendungsfall in eine separate Antwort ein, damit über ihn abgestimmt werden kann. Wenn Sie wissen, wie Sie eine der Antworten ohne den Präprozessor erreichen können, geben Sie in den Kommentaren dieser Antwort an, wie.

Als Wrapper für Debug - Funktionen, übergeben , um automatisch Dinge wie __FILE__, __LINE__etc:

#ifdef ( DEBUG )
#define M_DebugLog( msg )  std::cout << __FILE__ << ":" << __LINE__ << ": " << msg
#else
#define M_DebugLog( msg )
#endif

Methoden müssen immer vollständiger, kompilierbarer Code sein; Makros können Codefragmente sein. So können Sie ein foreach-Makro definieren:

#define foreach(list, index) for(index = 0; index < list.size(); index++)

Und benutze es so:

foreach(cookies, i)
    printf("Cookie: %s", cookies[i]);

Seit C ++ 11 wird dies durch die bereichsbasierte for-Schleife ersetzt .

Header File Guards erfordern Makros.

Gibt es andere Bereiche, in denen Makros erforderlich sind ? Nicht viele (wenn überhaupt).

Gibt es andere Situationen, die von Makros profitieren? JA!!!

Ein Ort, an dem ich Makros verwende, ist mit sich sehr wiederholendem Code. Wenn ich beispielsweise C ++ - Code für andere Schnittstellen (.NET, COM, Python usw.) einbinde, muss ich verschiedene Arten von Ausnahmen abfangen. So mache ich das:

#define HANDLE_EXCEPTIONS \
catch (::mylib::exception& e) { \
    throw gcnew MyDotNetLib::Exception(e); \
} \
catch (::std::exception& e) { \
    throw gcnew MyDotNetLib::Exception(e, __LINE__, __FILE__); \
} \
catch (...) { \
    throw gcnew MyDotNetLib::UnknownException(__LINE__, __FILE__); \
}

Ich muss diese Fänge in jede Wrapper-Funktion einfügen. Anstatt jedes Mal die vollständigen Fangblöcke auszutippen, tippe ich einfach:

void Foo()
{
    try {
        ::mylib::Foo()
    }
    HANDLE_EXCEPTIONS
}

Dies erleichtert auch die Wartung. Wenn ich jemals einen neuen Ausnahmetyp hinzufügen muss, muss ich ihn nur an einer Stelle hinzufügen.

Es gibt auch andere nützliche Beispiele: Viele davon enthalten die Makros __FILE__und und den __LINE__Präprozessor-Makros.

Auf jeden Fall sind Makros sehr nützlich, wenn sie richtig verwendet werden. Makros sind nicht böse - ihr Missbrauch ist böse.

Meist:

1. Wachen einschließen
2. Bedingte Kompilierung
3. Berichterstellung (vordefinierte Makros wie __LINE__und __FILE__)
4. (selten) Duplizieren sich wiederholender Codemuster.
5. Im Code Ihres Konkurrenten.

Innerhalb der bedingten Kompilierung, um Probleme mit Unterschieden zwischen Compilern zu überwinden:

#ifdef ARE_WE_ON_WIN32
#define close(parm1)            _close (parm1)
#define rmdir(parm1)            _rmdir (parm1)
#define mkdir(parm1, parm2)     _mkdir (parm1)
#define access(parm1, parm2)    _access(parm1, parm2)
#define create(parm1, parm2)    _creat (parm1, parm2)
#define unlink(parm1)           _unlink(parm1)
#endif

Wenn Sie aus einem Ausdruck eine Zeichenfolge machen möchten, ist das beste Beispiel dafür assert( #xwandelt den Wert von xin eine Zeichenfolge um).

#define ASSERT_THROW(condition) \
if (!(condition)) \
     throw std::exception(#condition " is false");

String-Konstanten werden manchmal besser als Makros definiert, da Sie mit String-Literalen mehr tun können als mit a const char *.

zB String-Literale können leicht verkettet werden .

#define BASE_HKEY "Software\\Microsoft\\Internet Explorer\\"
// Now we can concat with other literals
RegOpenKey(HKEY_CURRENT_USER, BASE_HKEY "Settings", &settings);
RegOpenKey(HKEY_CURRENT_USER, BASE_HKEY "TypedURLs", &URLs);

Wenn a const char *verwendet würde, müsste eine Art Zeichenfolgenklasse verwendet werden, um die Verkettung zur Laufzeit durchzuführen:

const char* BaseHkey = "Software\\Microsoft\\Internet Explorer\\";
RegOpenKey(HKEY_CURRENT_USER, (string(BaseHkey) + "Settings").c_str(), &settings);
RegOpenKey(HKEY_CURRENT_USER, (string(BaseHkey) + "TypedURLs").c_str(), &URLs);

Wenn Sie den Programmablauf ändern ( return, breakund continue) Code in einer Funktion verhält sich anders als Code, der tatsächlich in der Funktion inlined wird.

#define ASSERT_RETURN(condition, ret_val) \
if (!(condition)) { \
    assert(false && #condition); \
    return ret_val; }

// should really be in a do { } while(false) but that's another discussion.

Zu den offensichtlichen gehören Wachen

#ifndef MYHEADER_H
#define MYHEADER_H

...

#endif

Sie können Funktionsaufrufargumente nicht mit einem regulären Funktionsaufruf kurzschließen. Beispielsweise:

#define andm(a, b) (a) && (b)

bool andf(bool a, bool b) { return a && b; }

andm(x, y) // short circuits the operator so if x is false, y would not be evaluated
andf(x, y) // y will always be evaluated

Nehmen wir an, wir ignorieren offensichtliche Dinge wie Header Guards.

Manchmal möchten Sie Code generieren, der vom Precompiler kopiert / eingefügt werden muss:

#define RAISE_ERROR_STL(p_strMessage)                                          \
do                                                                             \
{                                                                              \
   try                                                                         \
   {                                                                           \
      std::tstringstream strBuffer ;                                           \
      strBuffer << p_strMessage ;                                              \
      strMessage = strBuffer.str() ;                                           \
      raiseSomeAlert(__FILE__, __FUNCSIG__, __LINE__, strBuffer.str().c_str()) \
   }                                                                           \
   catch(...){}                                                                \
   {                                                                           \
   }                                                                           \
}                                                                              \
while(false)

Damit können Sie Folgendes codieren:

RAISE_ERROR_STL("Hello... The following values " << i << " and " << j << " are wrong") ;

Und kann Nachrichten generieren wie:

Error Raised:
====================================
File : MyFile.cpp, line 225
Function : MyFunction(int, double)
Message : "Hello... The following values 23 and 12 are wrong"

Beachten Sie, dass das Mischen von Vorlagen mit Makros zu noch besseren Ergebnissen führen kann (dh die Werte werden automatisch neben ihren Variablennamen generiert).

In anderen Fällen benötigen Sie die __FILE__ und / oder die __LINE__ eines Codes, um beispielsweise Debug-Informationen zu generieren. Das Folgende ist ein Klassiker für Visual C ++:

#define WRNG_PRIVATE_STR2(z) #z
#define WRNG_PRIVATE_STR1(x) WRNG_PRIVATE_STR2(x)
#define WRNG __FILE__ "("WRNG_PRIVATE_STR1(__LINE__)") : ------------ : "

Wie beim folgenden Code:

#pragma message(WRNG "Hello World")

Es generiert Nachrichten wie:

C:\my_project\my_cpp_file.cpp (225) : ------------ Hello World

In anderen Fällen müssen Sie Code mit den Verkettungsoperatoren # und ## generieren, z. B. Getter und Setter für eine Eigenschaft generieren (dies gilt nur für sehr begrenzte Fälle).

In anderen Fällen generieren Sie Code, der bei Verwendung über eine Funktion nicht kompiliert werden kann, z.

#define MY_TRY      try{
#define MY_CATCH    } catch(...) {
#define MY_END_TRY  }

Welches kann als verwendet werden

MY_TRY
   doSomethingDangerous() ;
MY_CATCH
   tryToRecoverEvenWithoutMeaningfullInfo() ;
   damnThoseMacros() ;
MY_END_TRY

(Trotzdem habe ich diese Art von Code nur einmal richtig gesehen )

Zu guter Letzt das berühmte boost::foreach!!!

#include <string>
#include <iostream>
#include <boost/foreach.hpp>

int main()
{
    std::string hello( "Hello, world!" );

    BOOST_FOREACH( char ch, hello )
    {
        std::cout << ch;
    }

    return 0;
}

(Hinweis: Code kopieren / von der Boost-Homepage einfügen)

Welches ist (IMHO) viel besser als std::for_each.

Makros sind also immer nützlich, da sie außerhalb der normalen Compilerregeln liegen. Aber ich finde, dass die meiste Zeit, die ich sehe, tatsächlich Reste von C-Code sind, der nie in richtiges C ++ übersetzt wurde.

Unit-Test-Frameworks für C ++ wie UnitTest ++ drehen sich so ziemlich um Präprozessor-Makros. Ein paar Zeilen Unit-Test-Code erweitern sich zu einer Hierarchie von Klassen, deren manuelle Eingabe überhaupt keinen Spaß machen würde. Ohne etwas wie UnitTest ++ und seine Präprozessor-Magie weiß ich nicht, wie Sie Unit-Tests für C ++ effizient schreiben würden.

Den C-Präprozessor zu fürchten ist wie die Glühlampen zu fürchten, nur weil wir Leuchtstofflampen bekommen. Ja, ersteres kann {Strom | sein Programmierzeit} ineffizient. Ja, Sie können sich (buchstäblich) von ihnen verbrennen lassen. Aber sie können die Arbeit erledigen, wenn Sie richtig damit umgehen.

Wenn Sie eingebettete Systeme programmieren, ist C neben dem Form Assembler die einzige Option. Nachdem Sie mit C ++ auf dem Desktop programmiert und dann zu kleineren, eingebetteten Zielen gewechselt haben, lernen Sie, sich keine Gedanken mehr über „Uneleganzen“ so vieler nackter C-Funktionen (einschließlich Makros) zu machen und nur noch herauszufinden, wie Sie diese am besten und sichersten nutzen können Eigenschaften.

Alexander Stepanov sagt :

Wenn wir in C ++ programmieren, sollten wir uns nicht für das C-Erbe schämen, sondern es voll ausnutzen. Die einzigen Probleme mit C ++ und sogar die einzigen Probleme mit C treten auf, wenn sie selbst nicht mit ihrer eigenen Logik übereinstimmen.

Wir verwenden die Makros __FILE__und __LINE__für Diagnosezwecke beim Auslösen, Abfangen und Protokollieren von Informationen mit zahlreichen Ausnahmen sowie automatisierte Protokolldateiscanner in unserer QS-Infrastruktur.

Beispielsweise kann ein Auslösemakro OUR_OWN_THROWmit Ausnahmetyp- und Konstruktorparametern für diese Ausnahme verwendet werden, einschließlich einer Textbeschreibung. So was:

OUR_OWN_THROW(InvalidOperationException, (L"Uninitialized foo!"));

Dieses Makro löst natürlich die InvalidOperationExceptionAusnahme mit der Beschreibung als Konstruktorparameter aus, schreibt aber auch eine Nachricht in eine Protokolldatei, die aus dem Dateinamen und der Zeilennummer, in der der Wurf stattgefunden hat, und der Textbeschreibung besteht. Die ausgelöste Ausnahme erhält eine ID, die ebenfalls protokolliert wird. Wenn die Ausnahme jemals an einer anderen Stelle im Code abgefangen wird, wird sie als solche markiert, und die Protokolldatei zeigt an, dass diese bestimmte Ausnahme behandelt wurde und daher wahrscheinlich nicht die Ursache für einen Absturz ist, der später protokolliert wird. Nicht behandelte Ausnahmen können von unserer automatisierten QS-Infrastruktur problemlos erfasst werden.

Code-Wiederholung.

Schauen Sie sich die Präprozessor-Bibliothek an , es ist eine Art Meta-Meta-Programmierung. In Thema-> Motivation finden Sie ein gutes Beispiel.

Einige sehr fortgeschrittene und nützliche Dinge können immer noch mit Präprozessoren (Makros) erstellt werden, was Sie mit den c ++ - "Sprachkonstrukten" einschließlich Vorlagen niemals tun könnten.

Beispiele:

Machen Sie etwas sowohl zu einem C-Bezeichner als auch zu einer Zeichenfolge

Einfache Möglichkeit, Variablen von Aufzählungstypen als Zeichenfolge in C zu verwenden

Boost Preprocessor Metaprogramming

Ich verwende gelegentlich Makros, damit ich Informationen an einem Ort definieren kann, aber in verschiedenen Teilen des Codes auf unterschiedliche Weise. Es ist nur leicht böse :)

Zum Beispiel in "field_list.h":

/*
 * List of fields, names and values.
 */
FIELD(EXAMPLE1, "first example", 10)
FIELD(EXAMPLE2, "second example", 96)
FIELD(ANOTHER, "more stuff", 32)
...
#undef FIELD

Dann kann für eine öffentliche Aufzählung definiert werden, dass nur der Name verwendet wird:

#define FIELD(name, desc, value) FIELD_ ## name,

typedef field_ {

#include "field_list.h"

    FIELD_MAX

} field_en;

In einer privaten Init-Funktion können alle Felder verwendet werden, um eine Tabelle mit den Daten zu füllen:

#define FIELD(name, desc, value) \
    table[FIELD_ ## name].desc = desc; \
    table[FIELD_ ## name].value = value;

#include "field_list.h"

Eine häufige Verwendung ist das Erkennen der Kompilierungsumgebung. Für die plattformübergreifende Entwicklung können Sie beispielsweise einen Satz Code für Linux und einen anderen für Windows schreiben, wenn für Ihre Zwecke noch keine plattformübergreifende Bibliothek vorhanden ist.

In einem groben Beispiel kann also ein plattformübergreifender Mutex vorhanden sein

void lock()
{
    #ifdef WIN32
    EnterCriticalSection(...)
    #endif
    #ifdef POSIX
    pthread_mutex_lock(...)
    #endif
}

Für Funktionen sind sie nützlich, wenn Sie die Typensicherheit explizit ignorieren möchten. Wie die vielen Beispiele oben und unten für ASSERT. Natürlich können Sie sich wie bei vielen C / C ++ - Funktionen selbst in den Fuß schießen, aber die Sprache gibt Ihnen die Werkzeuge und lässt Sie entscheiden, was zu tun ist.

Etwas wie

void debugAssert(bool val, const char* file, int lineNumber);
#define assert(x) debugAssert(x,__FILE__,__LINE__);

So dass Sie nur zum Beispiel haben können

assert(n == true);

und erhalten Sie den Namen der Quelldatei und die Zeilennummer des Problems in Ihrem Protokoll, wenn n falsch ist.

Wenn Sie einen normalen Funktionsaufruf wie z

void assert(bool val);

Anstelle des Makros können Sie nur die Zeilennummer Ihrer Assert-Funktion erhalten, die in das Protokoll gedruckt wird, was weniger nützlich wäre.

#define ARRAY_SIZE(arr) (sizeof arr / sizeof arr[0])

Im Gegensatz zu der in einem aktuellen Thread beschriebenen "bevorzugten" Vorlagenlösung können Sie sie als konstanten Ausdruck verwenden:

char src[23];
int dest[ARRAY_SIZE(src)];

Sie können #defines verwenden, um beim Debuggen und bei Unit-Testszenarien zu helfen. Erstellen Sie beispielsweise spezielle Protokollierungsvarianten der Speicherfunktionen und erstellen Sie eine spezielle memlog_preinclude.h:

#define malloc memlog_malloc
#define calloc memlog calloc
#define free memlog_free

Kompilieren Sie Ihren Code mit:

gcc -Imemlog_preinclude.h ...

Ein Link in Ihrer memlog.o zum endgültigen Bild. Sie steuern jetzt malloc usw., möglicherweise zu Protokollierungszwecken oder um Simulationsfehler für Komponententests zu simulieren.

Wenn Sie zur Kompilierungszeit eine Entscheidung über das Compiler / OS / Hardware-spezifische Verhalten treffen.

Damit können Sie Ihre Schnittstelle zu Comppiler / OS / Hardware-spezifischen Funktionen gestalten.

#if defined(MY_OS1) && defined(MY_HARDWARE1)
#define   MY_ACTION(a,b,c)      doSothing_OS1HW1(a,b,c);}
#elif define(MY_OS1) && defined(MY_HARDWARE2)
#define   MY_ACTION(a,b,c)      doSomthing_OS1HW2(a,b,c);}
#elif define(MY_SUPER_OS)
          /* On this hardware it is a null operation */
#define   MY_ACTION(a,b,c)
#else
#error  "PLEASE DEFINE MY_ACTION() for this Compiler/OS/HArdware configuration"
#endif

Ich benutze Makros, um Ausnahmen einfach zu definieren:

DEF_EXCEPTION(RessourceNotFound, "Ressource not found")

wo DEF_EXCEPTION ist

#define DEF_EXCEPTION(A, B) class A : public exception\
  {\
  public:\
    virtual const char* what() const throw()\
    {\
      return B;\
    };\
  }\

Compiler können Ihre Inline-Anfrage ablehnen.

Makros werden immer ihren Platz haben.

Etwas, das ich nützlich finde, ist #define DEBUG für die Debug-Ablaufverfolgung - Sie können es 1 lassen, während Sie ein Problem debuggen (oder es sogar während des gesamten Entwicklungszyklus aktiviert lassen) und es dann ausschalten, wenn es Zeit für den Versand ist.

In meinem letzten Job habe ich an einem Virenscanner gearbeitet. Um mir das Debuggen zu erleichtern, hatte ich überall viel Protokollierung, aber in einer solchen App mit hoher Nachfrage sind die Kosten für einen Funktionsaufruf einfach zu hoch. Also habe ich mir dieses kleine Makro ausgedacht, mit dem ich immer noch die Debug-Protokollierung für eine Release-Version bei einem Kunden aktivieren konnte, ohne dass die Kosten eines Funktionsaufrufs das Debug-Flag überprüfen und einfach zurückkehren würden, ohne etwas zu protokollieren, oder falls aktiviert , würde die Protokollierung durchführen ... Das Makro wurde wie folgt definiert:

#define dbgmsg(_FORMAT, ...)  if((debugmsg_flag  & 0x00000001) || (debugmsg_flag & 0x80000000))     { log_dbgmsg(_FORMAT, __VA_ARGS__);  }

Aufgrund der VA_ARGS in den Protokollfunktionen war dies ein guter Fall für ein Makro wie dieses.

Zuvor habe ich in einer Hochsicherheitsanwendung ein Makro verwendet, das dem Benutzer mitteilen musste, dass er nicht über den richtigen Zugriff verfügt, und das ihm mitteilte, welches Flag er benötigt.

Die Makros sind definiert als:

#define SECURITY_CHECK(lRequiredSecRoles) if(!DoSecurityCheck(lRequiredSecRoles, #lRequiredSecRoles, true)) return
#define SECURITY_CHECK_QUIET(lRequiredSecRoles) (DoSecurityCheck(lRequiredSecRoles, #lRequiredSecRoles, false))

Dann könnten wir die Überprüfungen einfach über die gesamte Benutzeroberfläche streuen und Ihnen mitteilen, welche Rollen die von Ihnen versuchte Aktion ausführen dürfen, wenn Sie diese Rolle noch nicht haben. Der Grund für zwei von ihnen war, an einigen Stellen einen Wert zurückzugeben und an anderen von einer leeren Funktion zurückzukehren ...

SECURITY_CHECK(ROLE_BUSINESS_INFORMATION_STEWARD | ROLE_WORKER_ADMINISTRATOR);

LRESULT CAddPerson1::OnWizardNext() 
{
   if(m_Role.GetItemData(m_Role.GetCurSel()) == parent->ROLE_EMPLOYEE) {
      SECURITY_CHECK(ROLE_WORKER_ADMINISTRATOR | ROLE_BUSINESS_INFORMATION_STEWARD ) -1;
   } else if(m_Role.GetItemData(m_Role.GetCurSel()) == parent->ROLE_CONTINGENT) {
      SECURITY_CHECK(ROLE_CONTINGENT_WORKER_ADMINISTRATOR | ROLE_BUSINESS_INFORMATION_STEWARD | ROLE_WORKER_ADMINISTRATOR) -1;
   }
...

Wie auch immer, so habe ich sie verwendet, und ich bin mir nicht sicher, wie dies mit Vorlagen hätte geholfen werden können ... Abgesehen davon versuche ich, sie zu vermeiden, es sei denn, dies ist WIRKLICH notwendig.

Noch ein foreach-Makro. T: Typ, c: Container, i: Iterator

#define foreach(T, c, i) for(T::iterator i=(c).begin(); i!=(c).end(); ++i)
#define foreach_const(T, c, i) for(T::const_iterator i=(c).begin(); i!=(c).end(); ++i)

Verwendung (Konzept zeigt, nicht real):

void MultiplyEveryElementInList(std::list<int>& ints, int mul)
{
    foreach(std::list<int>, ints, i)
        (*i) *= mul;
}

int GetSumOfList(const std::list<int>& ints)
{
    int ret = 0;
    foreach_const(std::list<int>, ints, i)
        ret += *i;
    return ret;
}

Bessere Implementierungen verfügbar: Google "BOOST_FOREACH"

Gute Artikel verfügbar: Bedingte Liebe: FOREACH Redux (Eric Niebler) http://www.artima.com/cppsource/foreach.html

Möglicherweise liegt die größte Verwendung von Makros in der plattformunabhängigen Entwicklung. Denken Sie an Fälle von Typinkonsistenz - mit Makros können Sie einfach verschiedene Header-Dateien verwenden - wie: --WIN_TYPES.H

typedef ...some struct

--POSIX_TYPES.h

typedef ...some another struct

--program.h

#ifdef WIN32
#define TYPES_H "WINTYPES.H"
#else 
#define TYPES_H "POSIX_TYPES.H"
#endif

#include TYPES_H

Meiner Meinung nach viel lesbarer als auf andere Weise umzusetzen.

VA_ARGS wurden bisher anscheinend nur indirekt erwähnt:

Wenn Sie generischen C ++ 03-Code schreiben und eine variable Anzahl von (generischen) Parametern benötigen, können Sie anstelle einer Vorlage ein Makro verwenden.

#define CALL_RETURN_WRAPPER(FnType, FName, ...)          \
  if( FnType theFunction = get_op_from_name(FName) ) {   \
    return theFunction(__VA_ARGS__);                     \
  } else {                                               \
    throw invalid_function_name(FName);                  \
  }                                                      \
/**/

_{Hinweis: Im Allgemeinen kann der Name check / throw auch in die hypothetische get_op_from_nameFunktion integriert werden. Dies ist nur ein Beispiel. Möglicherweise enthält der VA_ARGS-Aufruf einen anderen generischen Code.}

Sobald wir mit C ++ 11 verschiedene Vorlagen erhalten haben, können wir diese "richtig" mit einer Vorlage lösen.

Ich denke, dieser Trick ist eine clevere Verwendung des Präprozessors, die mit einer Funktion nicht emuliert werden kann:

#define COMMENT COMMENT_SLASH(/)
#define COMMENT_SLASH(s) /##s

#if defined _DEBUG
#define DEBUG_ONLY
#else
#define DEBUG_ONLY COMMENT
#endif

Dann können Sie es so verwenden:

cout <<"Hello, World!" <<endl;
DEBUG_ONLY cout <<"This is outputed only in debug mode" <<endl;

Sie können auch ein RELEASE_ONLY-Makro definieren.

Sie können #defineKonstanten in der Compiler-Befehlszeile mit der Option -Doder /Dfestlegen. Dies ist häufig nützlich, wenn Sie dieselbe Software für mehrere Plattformen übergreifend kompilieren, da Sie mit Ihren Makefiles steuern können, welche Konstanten für jede Plattform definiert werden.