Was ist dieses mysteriöse Makro-Pluszeichen in stdint.h?

Siehe bitte meinen Code:

#include <stdint.h>

int main(int argc, char *argv[])
{
unsigned char s = 0xffU;
char ch = 0xff;
int val = 78;
((int8_t) + (78)); /*what does this mean*/

INT8_C(val);    /*equivalent to above*/

signed char + 78; /*not allowed*/

return 0;
}

Ich finde, dass die Makrodefinition in <stdint.h> ist:

#define INT8_C(val) ((int8_t) + (val))

Was ist die Bedeutung oder Bedeutung dieses Pluszeichens?

Der Ausschnitt:

((int8_t) + (78));

ist ein Ausdruck, eine, die den Wert annimmt 78wendet das Unäre an +wandelt das dann in ein um int8_t Typ, bevor Sie es wegwerfen. Es unterscheidet sich nicht wirklich von den juristischen Ausdrücken:

42;
a + 1;

die auch die Ausdrücke auswerten und dann das Ergebnis verwerfen (obwohl diese möglicherweise nicht mehr existieren, wenn der Compiler feststellen kann, dass es keine Nebenwirkungen gibt).

Diese “nackten” Ausdrücke sind in C vollkommen gültig und im Allgemeinen nur nützlich, wenn sie Nebenwirkungen haben, wie z. B. with i++das rechnet i und wirft es weg mit dem Nebeneffekt, dass es den Wert erhöht.

Die Art wie du sollte Dieses Makro zu verwenden, ist eher wie folgt:

int8_t varname = INT8_C (somevalue);

Der Grund für das scheinbar überflüssige Unary + Operator finden Sie im Standard. C99 zitieren 6.5.3.3 Unary arithmetic operators /1:

Der Operand des unären Operators + oder – muss vom arithmetischen Typ sein;

Und in 6.2.5 Types, /18:

Integer- und Floating-Typen werden gemeinsam als arithmetische Typen bezeichnet.

Mit anderen Worten, das Unäre + verhindert, dass Sie alle anderen Datentypen im Makro verwenden, wie z. B. Zeiger, komplexe Zahlen oder Strukturen.

Und zum Schluss der Grund für Sie:

signed char + 78;

Snippet funktioniert nicht, weil es nicht dasselbe ist. Dieser fängt an, eine Variable vom Typ zu deklarieren signed char aber erstickt, wenn es an die kommt + da dies kein gültiger Variablenname ist. Um es Ihrem Arbeits-Snippet äquivalent zu machen, würden Sie Folgendes verwenden:

(signed char) + 78;

das ist das Gießen des Wertes +78 tippen signed char.

Und gemäß C99 7.8.14 Macros for integer constants /2sollten Sie auch bei der Verwendung von Nicht-Konstanten in diesen Makros vorsichtig sein, es ist nicht garantiert, dass sie funktionieren:

Das Argument in jeder Instanz dieser Makros muss eine ganzzahlige Konstante ohne Suffix (wie in 6.4.4.1 definiert) mit einem Wert sein, der die Grenzen für den entsprechenden Typ nicht überschreitet.

6.4.4.1 spezifiziert einfach die verschiedenen Integer-Formate (dezimal/oktal/hex) mit den verschiedenen Suffixen (U, UL, ULL, L, LL und die Äquivalente in Kleinbuchstaben, je nach Typ). Die Quintessenz ist, dass sie es sein müssen Konstanten eher als Variablen.

Zum Beispiel, glibc hat:

# define INT8_C(c)      c
# define INT16_C(c)     c
# define INT32_C(c)     c
# if __WORDSIZE == 64
#  define INT64_C(c)    c ## L
# else
#  define INT64_C(c)    c ## LL
# endif

die es Ihnen ermöglichen INT8_C Makro funktioniert gut, aber der Text INT64_C(val) würde zu beiden vorverarbeitet werden valL oder valLLvon denen Sie beide nicht wollen würden.

Anscheinend hat hier jeder den Punkt des unären Plus-Operators verpasst, der das Ergebnis in gültig machen soll #if Präprozessor-Direktiven. Gegeben:

#define INT8_C(val) ((int8_t) + (val))

die Richtlinien:

#define FOO 1
#if FOO == INT8_C(1)

erweitern als:

#if 1 == ((0) + (1))

und funktionieren somit wie erwartet. Dies liegt daran, dass jede un#defined-Symbol in einem #if Direktive erweitert sich zu 0.

Ohne das unäre Plus (das in ein binäres Plus wird #if Direktiven), wäre der Ausdruck nicht gültig in #if Richtlinien.

Es ist ein Unär + Operator. Sie liefert den Wert ihres Operanden, kann aber nur auf arithmetische Typen angewendet werden. Der Zweck hier ist, die Verwendung von zu verhindern INT8_C auf einem Ausdruck vom Typ Zeiger.

Aber Ihr Aussageausdruck

INT8_C(val);

hat undefiniertes Verhalten. Das Argument zu INT8_C() muss “eine ganzzahlige Konstante ohne Suffix … mit einem Wert sein, der die Grenzen für den entsprechenden Typ nicht überschreitet” (N1256 7.18.4). Die Absicht dieser Makros ist es, Sie so etwas wie schreiben zu lassen INT64_C(42) und lassen Sie es erweitern 42L wenn int64_t ist longoder zu 42LL wenn int64_t ist `lang lang, und so weiter.

Aber schreiben auch nicht

((int8_t) + (78));

oder

((int8_t) + (val));

in Ihrem eigenen Code ist vollkommen legal.

BEARBEITEN:

Die Definition für INT8_C() in der frage:

#define INT8_C(val) ((int8_t) + (val))

ist in C99 gültig, aber nicht konform gemäß dem späteren Entwurf N1256, aufgrund einer Änderung in einer der Technischen Berichtigungen.

Der ursprüngliche C99-Standard, Abschnitt 7.18.4.1p2, sagt:

Das Makro INT***N*_C**(Wert) wird zu einer vorzeichenbehafteten ganzzahligen Konstante mit dem angegebenen Wert und Typ erweitert int_least***N*_t**.

N1256 änderte dies zu (Absatz 3):

Jeder Aufruf eines dieser Makros wird zu einem ganzzahligen konstanten Ausdruck erweitert, der zur Verwendung in geeignet ist #wenn Vorverarbeitungsanweisungen. Der Typ des Ausdrucks muss denselben Typ haben wie ein Ausdruck des entsprechenden Typs, der gemäß den ganzzahligen Heraufstufungen konvertiert wurde. Der Wert des Ausdrucks soll der des Arguments sein.

Die Änderung erfolgte als Reaktion auf Fehlerbericht Nr. 209.

EDIT2: Aber siehe die Antwort von R..; es ist tatsächlich in N1256 gültig, aus ziemlich obskuren Gründen.

Das ist ein unärer Pluspunkt.

Es gibt nur zwei Dinge könnte tun.

1. Es gilt, was bekannt ist als die übliche arithmetische Umrechnungen zum Operanden. Dies stellt eine gemeinsamer realer Typ für ein Ergebnis. Ich kann mir keinen Grund vorstellen, dies zu erzwingen, wenn das Ergebnis in etwas Bestimmtes umgewandelt werden soll.

2. Es schränkt den Operanden auf Typen ein, für die arithmetische Operatoren definiert sind. Dies scheint der wahrscheinlichere Grund zu sein.