Was ist der Unterschied in der Praxis zwischen inline-und #define?

Funktionen (ob inline oder nicht) und Makros erfüllen unterschiedliche Zwecke. Der Unterschied, das sollte man nicht als ideologische, wie einige scheinen, es zu nehmen, und, was noch wichtiger ist, Sie arbeiten gut zusammen.

Makros sind text-replacement, erfolgt zur compile-Zeit, und Sie können Dinge tun, wie

#define P99_ISSIGNED(T) ((T)-1 < (T)0)

die Ihnen eine compile-Zeit-Ausdruck, ob oder ob nicht ein integraler Typ ist, unterzeichnet oder nicht. Das heißt, Sie sind ideal eingesetzt, wenn der Typ eines Ausdrucks nicht bekannt ist (bei der definition) und Sie wollen etwas dagegen tun. Auf der anderen Seite, das Problem mit Makros ist, dass Ihre Argumente evaluiert werden kann mehrere Male, das ist schlecht wegen der Nebenwirkungen.

Funktionen (inline) auf der anderen eingegeben werden, das macht Sie strenger, oder, negativ formuliert, weniger flexibel. Betrachten Sie die Funktionen

inline uintmax_t absU(uintmax_t a) { return a; }
inline uintmax_t absS(uintmax_t a) {
   return (-a < a) ? -a : a;
}

Den ersten implementiert das trivial abs Funktion für eine vorzeichenlose Integrale Typ. Die zweite setzt es für einen signed-Typ. (ja, es dauert eine vorzeichenlose als argument, ist dies für den Zweck.)

Wir können diese mit beliebigen ganzzahligen Typ. Aber der Rückgabetyp wird immer von der größten Breite und es gibt eine gewisse Schwierigkeit, zu wissen, wie Sie wählen Sie zwischen den beiden.

Nun mit dem folgenden makro

#define ABS(T, A) ((T)(P99_ISSIGNED(T) ? absS : absU)(A))

haben wir umgesetzt

• Familie von Funktionen
• dass für alle ganzzahligen Typ
• wertet das argument nur einmal
• für die jüngsten und anständig
  der compiler wird bei der Schaffung von optimalen code

(Gut, ich gebe zu, dass dies mit abs ist ein bisschen künstlich, aber ich hoffe, Sie bekommen das Bild.)

Gut, eine multi-line - #define ist schwieriger zu schreiben und zu Bearbeiten, als eine inline-Funktion. Sie können die Definition einer inline-Funktion genauso wie eine normale Funktion, und definieren können Variablen ohne Probleme. Angenommen, Sie möchten rufen Sie einen code-block mehrere Male innerhalb einer anderen Funktion, und dieser code-block muss seine eigenen Variablen: es ist einfacher, mit inline-Funktionen (ja, Sie können dies tun, mit #defines und do { ... } while (0); aber es ist etwas, was Sie zu denken haben).

Auch, mit aktivierten debugging, normalerweise bekommt man eine "simulierte" stack-frame für inline-Funktionen, die machen könnte einfacher Debuggen, manchmal (zumindest das ist, was Sie bekommen, wenn Sie die Compiler - /link-mit gcc -g und Debuggen mit GDB, wenn ich mich Recht erinnere). Sie können Haltepunkte in Ihre inline-würde-Funktion.

Abgesehen davon sollte das Ergebnis fast identisch, AFAIK.

Function-like Makros geben Ihnen absolut null sanity checks an der Stelle, wo Sie definiert sind. Wenn Sie die Schraube mit einem makro, es wird funktionieren gut in einem Ort gebrochen, irgendwo anders, und man weiß nicht, warum, bis Sie verloren haben, mehrere Stunden Arbeit/Zeit schlafen. Function-like Makros funktionieren nicht auf Daten, die Sie betreiben, auf dem source-code. Manchmal ist dies gut, zum Beispiel, wenn Sie wollen, wieder verwendbare debug-Anweisungen verwenden DATEI und LINIE gelieferten, aber die meisten der Zeit, es kann getan werden, ebenso gut mit einer inline-Funktion, die überprüft, die syntax an der Stelle der definition genau wie jede andere Funktion.