`struct X typedef`와`typedef struct X`의 의미는 무엇입니까?

`struct X typedef`와`typedef struct X`의 의미는 무엇입니까?

---

MSVC (2010) 및 Windows DDK에서 컴파일하는 C와 C ++간에 공유되는 포함 파일에 사용되는 기존 코드베이스에 다음과 같은 (작동하는) 코드가 있습니다.

struct X {
    USHORT x;
} typedef X, *PX;

과:

enum MY_ENUM {
    enum_item_1,
    enum_item_2 
} typedef MY_ENUM;

내가 아는 한 올바른 정의는 다음과 같아야합니다.

typedef struct {
    USHORT x;
} X, *PX;

아래 양식을 갖는 목적이 있습니까? 내가 뭔가를 놓치고 있습니까?

---

typedef <type> <alias>및 둘 다 <type> typedef <alias>유효 하다는 사실 은 단순히 언어 문법 정의에서 비롯됩니다.

typedef, 처럼 스토리지 클래스 지정자 로 분류되며 유형 자체는 유형 지정 자라고 합니다 . 표준의 섹션 6.7에있는 구문 정의에서 다음과 같이 자유롭게 변경할 수 있음을 알 수 있습니다.staticauto

declaration:
    declaration-specifiers init-declarator-list ;

declaration-specifiers:
    storage-class-specifier declaration-specifiers
    type-specifier declaration-specifiers
    type-qualifier declaration-specifiers
    function-specifier declaration-specifiers

init-declarator-list:
    init-declarator
    init-declarator-list , init-declarator

init-declarator:
    declarator
    declarator = initializer

(물론, 이것은 구조체와 비 구조체에 대해서도 똑같이 적용된다는 점에 유의 double typedef trouble;하십시오. 이는 또한 유효 함을 의미 합니다.)

---

다른 사람들이 말했듯 typedef이은 스토리지 클래스 지정자이며 다른 스토리지 클래스 지정자와 마찬가지로 유형과 선언자 사이에 지정자를 넣을 수 있습니다.

이것이 유효하고 C가 노후화 기능으로 표시했기 때문에 피해야하는 형식이기도합니다.

(C11, 6.11.5p1) "선언에서 선언 지정자의 시작 부분이 아닌 스토리지 클래스 지정자의 배치는 더 이상 사용되지 않는 기능입니다."

---

둘 다 같은 의미를 가지고 있습니다. 다음 두 형식 모두 유효합니다.

typedef <existing_type> <new_type>
<existing_type> typedef <new_type>   

typedef위의 구조체는 두 가지 방법 중 하나로 사용할 수 있습니다 .

struct X {
    USHORT x;
}typedef X, *PX;     // <existing_type> typedef <new_type> 

또는

typedef struct {
    USHORT x;
} X, *PX;            // typedef <existing_type> <new_type>

---

You really are allowed to put all the declaration specifiers in any order you want! The positions of any * pointers and the actual declarator (the variable or new type name) matter, but all that typedef int unsigned const static etc. stuff can be in any order.

If you look at the official grammar of C, it just says:

declaration:
    declaration-specifiers init-declarator-list ;

The declaration-specifiers are all the storage class specifiers (typedef, extern, etc.), type specifiers (the actual type, like int or struct X), type qualifiers (const and volatile), and a few other less common ones. Their order is not important. The second part is the init-declarator-list, and it's the variable or new type name (in the case of a typedef), any * characters, the initialization of the variable (int x = 3), and more. The order of things in the declarator part is important, but not the order in the declaration specifiers.

---

Disclaimer: This is not a technical but a practical answer. Refer to the other answers for technical matters. This answer reads opinionated and subjective but please bear with me while I try to explain the bigger picture.

struct is a strange beast because the stuff you put between the closing bracket } and the semicolon ; refers to the content inside or before those brackets. I know why that is, and grammatically it does make sense, but personally I find it very counter-intuitive as curly brackets usually mean scope:

Counter-intuitive examples:

// declares a variable named `foo` of unnamed struct type.
struct {
    int x, y;
} foo;

foo.x = 1;


// declares a type named `Foo` of unnamed struct type
struct {
    int x, y;
} typedef Foo;

Foo foo2;
foo2.x = 2;


// declares a type named `Baz` of the struct named `Bar`
struct Bar {
    int x, y;
} typedef Baz;

// note the 'struct' keyword to actually use the type 'Bar'
struct Bar bar;
bar.x = 3;
Baz baz;
baz.x = 4;

There are so many subtle things that can go wrong with the dense syntax of structs and typedefs if used like this. As shown below it is very easy to declare a variable instead of a type by accident. The compiler is only of limited help because almost all combinations are grammatically correct. They just don't necessarily mean what you try to express. It is a pit of despair.

Wrong examples:

// mixed up variable and type declaration
struct foo {
    int x, y;
} Foo;

// declares a type 'foo' instead of a variable
typedef struct Foo {
    int x, y;
} foo;

// useless typedef but compiles fine
typedef struct Foo {
    int x, y;
};

// compiler error
typedef Foo struct {
    int x, y;
};

For reasons of readability and maintenance I prefer to declare everything separately and never put anything behind the closing curly bracket. The cost of additional lines of code are easily outweighed by intuitive syntax. I argue that this approach makes it easy to do the right things and annoying to do the wrong things.

Intuitive examples:

// declares a struct named 'TVector2'
struct TVector2 {
    float x, y;
};

// declares a type named 'Vector2' to get rid of the 'struct' keyword
// note that I really never use 'TVector2' afterwards
typedef struct TVector2 Vector2;

Vector2 v, w;
v.x = 0;
v.y = 1;

ReferenceURL : https://stackoverflow.com/questions/24227816/what-is-the-meaning-of-struct-x-typedef-vs-typedef-struct-x