Saya telah melihat banyak program yang terdiri dari struktur seperti di bawah ini

typedef struct 
{
    int i;
    char k;
} elem;

elem user;

Mengapa begitu sering dibutuhkan? Adakah alasan khusus atau bidang yang dapat diterapkan?

Seperti kata Greg Hewgill, typedef berarti Anda tidak perlu lagi menulis di structsemua tempat. Itu tidak hanya menyimpan penekanan tombol, itu juga dapat membuat kode lebih bersih karena memberikan sedikit lebih banyak abstraksi.

Hal-hal seperti

typedef struct {
  int x, y;
} Point;

Point point_new(int x, int y)
{
  Point a;
  a.x = x;
  a.y = y;
  return a;
}

menjadi lebih bersih ketika Anda tidak perlu melihat kata kunci "struct" di semua tempat, itu terlihat lebih seolah-olah ada jenis yang disebut "Point" dalam bahasa Anda. Yang, setelah itu typedef, adalah kasus saya kira.

Perhatikan juga bahwa ketika contoh Anda (dan milik saya) mengabaikan penamaan struct itu sendiri, sebenarnya penamaan itu juga berguna ketika Anda ingin memberikan jenis buram. Maka Anda akan memiliki kode seperti ini di header, misalnya:

typedef struct Point Point;

Point * point_new(int x, int y);

dan kemudian memberikan structdefinisi dalam file implementasi:

struct Point
{
  int x, y;
};

Point * point_new(int x, int y)
{
  Point *p;
  if((p = malloc(sizeof *p)) != NULL)
  {
    p->x = x;
    p->y = y;
  }
  return p;
}

Dalam kasus yang terakhir ini, Anda tidak dapat mengembalikan Poin dengan nilai, karena definisinya disembunyikan dari pengguna file header. Ini adalah teknik yang digunakan secara luas di GTK + , misalnya.

UPDATE Perhatikan bahwa ada juga proyek-proyek C yang sangat terkenal di mana penggunaan typedefuntuk menyembunyikan structini dianggap sebagai ide yang buruk, kernel Linux mungkin adalah proyek yang paling terkenal. Lihat Bab 5 dokumen The Linux Kernel CodingStyle untuk kata-kata marah Linus. :) Maksud saya adalah bahwa "harus" dalam pertanyaan itu mungkin tidak diatur, setelah semua.

Sungguh menakjubkan berapa banyak orang yang melakukan kesalahan ini. TOLONG jangan mengetik struct di C, itu tidak perlu mencemari namespace global yang biasanya sudah sangat tercemar di program C besar.

Juga, struct yang diketik tanpa nama tag adalah penyebab utama pemaksaan hubungan pemesanan yang tidak perlu di antara file header.

Mempertimbangkan:

#ifndef FOO_H
#define FOO_H 1

#define FOO_DEF (0xDEADBABE)

struct bar; /* forward declaration, defined in bar.h*/

struct foo {
  struct bar *bar;
};

#endif

Dengan definisi seperti itu, tidak menggunakan typedef, adalah mungkin bagi unit compiland untuk memasukkan foo.h untuk mendapatkan FOO_DEFdefinisi tersebut. Jika tidak mencoba untuk melakukan dereferensi anggota 'bar' dari foostruct maka tidak perlu menyertakan file "bar.h".

Juga, karena ruang nama berbeda antara nama tag dan nama anggota, dimungkinkan untuk menulis kode yang sangat mudah dibaca seperti:

struct foo *foo;

printf("foo->bar = %p", foo->bar);

Karena ruang nama terpisah, tidak ada konflik dalam penamaan variabel yang bertepatan dengan nama tag struct mereka.

Jika saya harus menjaga kode Anda, saya akan menghapus struct typedef'd Anda.

Dari artikel lama oleh Dan Saks ( http://www.ddj.com/cpp/184403396?pgno=3 ):

Aturan bahasa C untuk penamaan struct agak eksentrik, tetapi cukup berbahaya. Namun, ketika diperluas ke kelas-kelas di C ++, aturan-aturan yang sama membuka sedikit celah bagi bug untuk menjelajah.

Di C, namanya muncul di

struct s
    {
    ...
    };

adalah sebuah tag. Nama tag bukan nama jenis. Mengingat definisi di atas, deklarasi seperti

s x;    /* error in C */
s *p;   /* error in C */

ada kesalahan dalam C. Anda harus menuliskannya sebagai

struct s x;     /* OK */
struct s *p;    /* OK */

Nama-nama serikat pekerja dan enumerasi juga merupakan tag dan bukan tipe.

Di C, tag berbeda dari semua nama lain (untuk fungsi, tipe, variabel, dan konstanta enumerasi). Kompiler C memelihara tag dalam tabel simbol yang secara konseptual jika tidak secara fisik terpisah dari tabel yang menampung semua nama lain. Dengan demikian, dimungkinkan bagi program C untuk memiliki tag dan nama lain dengan ejaan yang sama dalam cakupan yang sama. Sebagai contoh,

struct s s;

adalah deklarasi yang valid yang menyatakan variabel s dari tipe struct s. Ini mungkin bukan praktik yang baik, tetapi kompiler C harus menerimanya. Saya belum pernah melihat alasan mengapa C dirancang dengan cara ini. Saya selalu berpikir itu adalah kesalahan, tapi itu dia.

Banyak programmer (termasuk Anda yang benar-benar) lebih suka menganggap nama struct sebagai nama tipe, sehingga mereka mendefinisikan alias untuk tag menggunakan typedef. Misalnya, mendefinisikan

struct s
    {
    ...
    };
typedef struct s S;

memungkinkan Anda menggunakan S sebagai ganti struct, seperti pada

S x;
S *p;

Suatu program tidak dapat menggunakan S sebagai nama tipe dan variabel (atau konstanta fungsi atau enumerasi):

S S;    // error

Ini bagus.

Nama tag dalam definisi struct, gabungan, atau enum adalah opsional. Banyak programmer melipat definisi struct ke dalam typedef dan membuang tag sama sekali, seperti pada:

typedef struct
    {
    ...
    } S;

Artikel yang ditautkan juga memiliki diskusi tentang bagaimana perilaku C ++ yang tidak memerlukan typedefdapat menyebabkan masalah persembunyian nama halus. Untuk mencegah masalah ini, itu ide yang bagus untuk typedefkelas dan struct Anda di C ++, juga, meskipun pada pandangan pertama tampaknya tidak perlu. Di C ++, dengan typedefnama bersembunyi menjadi kesalahan yang kompiler memberitahu Anda tentang daripada sumber tersembunyi dari potensi masalah.

Menggunakan typedefmenghindari harus menulis structsetiap kali Anda mendeklarasikan variabel jenis itu:

struct elem
{
 int i;
 char k;
};
elem user; // compile error!
struct elem user; // this is correct

Satu alasan bagus lainnya untuk selalu mengetik enum dan struct hasil dari masalah ini:

enum EnumDef
{
  FIRST_ITEM,
  SECOND_ITEM
};

struct StructDef
{
  enum EnuumDef MyEnum;
  unsigned int MyVar;
} MyStruct;

Perhatikan kesalahan ketik di EnumDef di struct (Enu u mDef)? Ini mengkompilasi tanpa kesalahan (atau peringatan) dan (tergantung pada interpretasi literal dari Standar C) yang benar. Masalahnya adalah bahwa saya baru saja membuat definisi enumerasi (kosong) baru dalam struct saya. Saya tidak (sebagaimana dimaksud) menggunakan definisi EnumDef sebelumnya.

Dengan typdef, kesalahan ketik yang serupa akan menghasilkan kesalahan kompiler untuk menggunakan jenis yang tidak dikenal:

typedef 
{
  FIRST_ITEM,
  SECOND_ITEM
} EnumDef;

typedef struct
{
  EnuumDef MyEnum; /* compiler error (unknown type) */
  unsigned int MyVar;
} StructDef;
StrructDef MyStruct; /* compiler error (unknown type) */

Saya akan menganjurkan SELALU mengetik struct dan enumerasi.

Bukan hanya untuk menyimpan beberapa pengetikan (tidak ada permainan kata-kata yang dimaksudkan;)), tetapi karena lebih aman.

Gaya pengkodean kernel Linux Bab 5 memberikan pro dan kontra (sebagian besar kontra) penggunaan typedef.

Tolong jangan gunakan hal-hal seperti "vps_t".

Merupakan kesalahan untuk menggunakan typedef untuk struktur dan pointer. Ketika Anda melihat a

vps_t a;

di sumbernya, apa artinya?

Sebaliknya, jika dikatakan

struct virtual_container *a;

Anda benar-benar dapat mengetahui apa itu "a".

Banyak orang berpikir bahwa mengetik "membantu keterbacaan". Tidak begitu. Mereka hanya berguna untuk:

(A) objek benar-benar buram (di mana typedef secara aktif digunakan untuk menyembunyikan apa objek itu).

Contoh: "pte_t" dll. Objek buram yang hanya dapat Anda akses menggunakan fungsi accessor yang tepat.

CATATAN! Ketidakjelasan dan "fungsi pengakses" tidak baik dalam diri mereka. Alasan kami memilikinya untuk hal-hal seperti pte_t dll. Adalah benar-benar nol informasi yang dapat diakses di sana.

(B) Hapus jenis integer, di mana abstraksi membantu menghindari kebingungan apakah itu "int" atau "panjang".

u8 / u16 / u32 adalah typedef yang sangat bagus, meskipun mereka masuk dalam kategori (d) lebih baik daripada di sini.

CATATAN! Sekali lagi - perlu ada alasan untuk ini. Jika ada sesuatu yang "tidak ditandai lama", maka tidak ada alasan untuk melakukannya

typedef unsigned long myflags_t;

tetapi jika ada alasan yang jelas mengapa itu dalam keadaan tertentu mungkin merupakan "unsigned int" dan di bawah konfigurasi lain mungkin "unsigned long", maka tentu saja silakan dan gunakan typedef.

(C) ketika Anda menggunakan jarang untuk benar-benar membuat tipe baru untuk pemeriksaan tipe.

(d) Tipe baru yang identik dengan tipe C99 standar, dalam keadaan tertentu tertentu.

Meskipun hanya membutuhkan waktu singkat bagi mata dan otak untuk menjadi terbiasa dengan tipe standar seperti 'uint32_t', toh sebagian orang tetap menolak penggunaannya.

Oleh karena itu, tipe 'u8 / u16 / u32 / u64' khusus Linux dan setara yang ditandatangani yang identik dengan tipe standar diizinkan - meskipun mereka tidak wajib dalam kode baru Anda sendiri.

Saat mengedit kode yang ada yang sudah menggunakan satu atau beberapa tipe lainnya, Anda harus menyesuaikan dengan pilihan yang ada dalam kode itu.

(e) Jenis aman untuk digunakan di ruang pengguna.

Dalam struktur tertentu yang terlihat oleh userspace, kami tidak dapat membutuhkan tipe C99 dan tidak dapat menggunakan formulir 'u32' di atas. Dengan demikian, kami menggunakan __u32 dan tipe serupa di semua struktur yang dibagi dengan userspace.

Mungkin ada kasus-kasus lain juga, tetapi aturan dasarnya harus TIDAK PERNAH menggunakan typedef kecuali Anda dapat dengan jelas mencocokkan salah satu aturan itu.

Secara umum, sebuah pointer, atau struct yang memiliki elemen yang dapat diakses secara langsung tidak boleh berupa typedef.

Ternyata ada pro dan kontra. Sumber informasi yang bermanfaat adalah buku mani "Pemrograman C Pakar" ( Bab 3 ). Secara singkat, di C Anda memiliki beberapa ruang nama: tag, tipe, nama anggota, dan pengidentifikasi . typedefmemperkenalkan alias untuk suatu jenis dan menempatkannya di tag namespace. Yaitu,

typedef struct Tag{
...members...
}Type;

mendefinisikan dua hal. Satu Tag di namespace tag dan satu Ketik dalam tipe namespace. Jadi Anda bisa melakukan keduanya Type myTypedan struct Tag myTagType. Deklarasi suka struct Type myTypeatau Tag myTagTypeilegal. Selain itu, dalam deklarasi seperti ini:

typedef Type *Type_ptr;

kita mendefinisikan pointer ke Tipe kita. Jadi jika kita menyatakan:

Type_ptr var1, var2;
struct Tag *myTagType1, myTagType2;

kemudian var1, var2dan myTagType1pointer ke Ketik tetapi myTagType2tidak.

Dalam buku yang disebutkan di atas, disebutkan bahwa struct typedefing tidak terlalu berguna karena hanya menyelamatkan programmer dari menulis kata struct. Namun, saya keberatan, seperti banyak programmer C lainnya. Meskipun kadang-kadang ternyata mengaburkan beberapa nama (itu sebabnya tidak disarankan dalam basis kode besar seperti kernel) ketika Anda ingin menerapkan polimorfisme dalam C, banyak membantu mencari di sini untuk rincian . Contoh:

typedef struct MyWriter_t{
    MyPipe super;
    MyQueue relative;
    uint32_t flags;
...
}MyWriter;

Anda dapat melakukan:

void my_writer_func(MyPipe *s)
{
    MyWriter *self = (MyWriter *) s;
    uint32_t myFlags = self->flags;
...
}

Jadi, Anda dapat mengakses anggota luar ( flags) dengan struct bagian dalam ( MyPipe) melalui casting. Bagi saya itu kurang membingungkan untuk melemparkan seluruh jenis daripada melakukan (struct MyWriter_ *) s;setiap kali Anda ingin melakukan fungsi seperti itu. Dalam kasus ini referensi singkat adalah masalah besar terutama jika Anda menggunakan teknik dalam kode Anda.

Akhirnya, aspek terakhir dengan typedeftipe ed adalah ketidakmampuan untuk memperpanjangnya, berbeda dengan makro. Jika misalnya, Anda memiliki:

#define X char[10] or
typedef char Y[10]

Anda kemudian dapat mendeklarasikan

unsigned X x; but not
unsigned Y y;

Kami tidak terlalu peduli untuk ini karena struct karena tidak berlaku untuk specifier penyimpanan ( volatiledan const).

Saya tidak berpikir deklarasi maju bahkan mungkin dengan typedef. Penggunaan struct, enum, dan union memungkinkan untuk meneruskan deklarasi ketika dependensi (tahu tentang) adalah dua arah.

Style: Penggunaan typedef di C ++ cukup masuk akal. Hampir bisa diperlukan ketika berhadapan dengan templat yang memerlukan banyak dan / atau parameter variabel. Typedef membantu menjaga penamaan tetap lurus.

Tidak demikian halnya dalam bahasa pemrograman C. Penggunaan typedef paling sering tidak memiliki tujuan selain mengaburkan penggunaan struktur data. Karena hanya {struct (6), enum (4), union (5)} jumlah penekanan tombol yang digunakan untuk mendeklarasikan tipe data, hampir tidak ada gunanya untuk alias alias struct. Apakah tipe data itu gabungan atau struktur? Menggunakan deklarasi non-typdefed langsung membuat Anda langsung tahu apa itu.

Perhatikan bagaimana Linux ditulis dengan menghindari ketat dari typedef omong kosong alias ini membawa. Hasilnya adalah gaya minimalis dan bersih.

Mari kita mulai dengan dasar-dasar dan terus maju.

Berikut adalah contoh definisi Struktur:

struct point
  {
    int x, y;
  };

Di sini namanya pointopsional.

Struktur dapat dideklarasikan selama definisi atau setelahnya.

Mendeklarasikan selama definisi

struct point
  {
    int x, y;
  } first_point, second_point;

Mendeklarasikan setelah definisi

struct point
  {
    int x, y;
  };
struct point first_point, second_point;

Sekarang, perhatikan baik-baik kasus terakhir di atas; Anda perlu menulis struct pointuntuk mendeklarasikan Struktur jenis itu jika Anda memutuskan untuk membuat jenis itu di kemudian hari dalam kode Anda.

Masukkan typedef. Jika Anda bermaksud membuat Struktur baru (Struktur adalah tipe data khusus) di lain waktu di program Anda menggunakan cetak biru yang sama, menggunakan typedefselama definisi mungkin merupakan ide yang bagus karena Anda dapat menyimpan beberapa pengetikan bergerak maju.

typedef struct point
  {
    int x, y;
  } Points;

Points first_point, second_point;

Sebuah kata hati-hati saat memberi nama jenis kustom Anda

Tidak ada yang mencegah Anda menggunakan akhiran _t di akhir nama jenis kustom Anda tetapi standar POSIX cadangan penggunaan akhiran _t untuk menunjukkan nama jenis perpustakaan standar.

nama yang Anda (opsional) berikan kepada struct disebut nama tag dan, seperti yang telah dicatat, bukan tipe itu sendiri. Untuk sampai ke tipe memerlukan awalan struct.

Selain GTK +, saya tidak yakin tagname digunakan seperti biasanya seperti typedef untuk tipe struct, jadi di C ++ yang dikenali dan Anda dapat menghilangkan kata kunci struct dan menggunakan tagname sebagai nama tipe juga:

    struct MyStruct
    {
      int i;
    };

    // The following is legal in C++:
    MyStruct obj;
    obj.i = 7;

typedef tidak akan menyediakan seperangkat struktur data yang saling tergantung. Ini tidak dapat Anda lakukan dengan typdef:

struct bar;
struct foo;

struct foo {
    struct bar *b;
};

struct bar {
    struct foo *f;
};

Tentu saja Anda selalu dapat menambahkan:

typedef struct foo foo_t;
typedef struct bar bar_t;

Apa sebenarnya gunanya itu?

A> typdef membantu dalam arti dan dokumentasi suatu program dengan memungkinkan pembuatan sinonim yang lebih bermakna untuk tipe data . Selain itu, mereka membantu membuat parameter program terhadap masalah portabilitas (K&R, pg147, C prog lang).

B> suatu struktur mendefinisikan suatu tipe . Structs memungkinkan pengelompokan yang mudah dari kumpulan vars untuk kenyamanan penanganan (K&R, pg127, C prog lang.) Sebagai satu unit

C> mengetikkan struct dijelaskan dalam A di atas.

D> Bagi saya, struct adalah tipe kustom atau wadah atau koleksi atau ruang nama atau tipe kompleks, sedangkan typdef hanyalah sarana untuk membuat lebih banyak nama panggilan.

Diperlukan mengetikkan C99. Itu sudah usang, tetapi banyak alat (ala HackRank) menggunakan c99 sebagai implementasi C murni. Dan typedef diperlukan di sana.

Saya tidak mengatakan mereka harus berubah (mungkin memiliki dua opsi C) jika persyaratannya berubah, kita yang sedang belajar untuk wawancara di situs adalah SOL.

Dalam bahasa pemrograman 'C' kata kunci 'typedef' digunakan untuk mendeklarasikan nama baru untuk beberapa objek (struct, array, function..enum type). Sebagai contoh, saya akan menggunakan 'struct-s'. Dalam 'C' kita sering menyatakan 'struct' di luar fungsi 'utama'. Sebagai contoh:

struct complex{ int real_part, img_part }COMPLEX;

main(){

 struct KOMPLEKS number; // number type is now a struct type
 number.real_part = 3;
 number.img_part = -1;
 printf("Number: %d.%d i \n",number.real_part, number.img_part);

}

Setiap kali saya memutuskan untuk menggunakan tipe struct saya akan membutuhkan kata kunci ini 'struct' something '' name '.' Typedef 'hanya akan mengubah nama tipe itu dan saya dapat menggunakan nama baru itu di program saya setiap kali saya mau. Jadi kode kita adalah:

typedef struct complex{int real_part, img_part; }COMPLEX;
//now COMPLEX is the new name for this structure and if I want to use it without
// a keyword like in the first example 'struct complex number'.

main(){

COMPLEX number; // number is now the same type as in the first example
number.real_part = 1;
number.img)part = 5;
printf("%d %d \n", number.real_part, number.img_part);

}

Jika Anda memiliki beberapa objek lokal (struct, array, bernilai) yang akan digunakan di seluruh program Anda, Anda bisa memberinya nama menggunakan 'typedef'.

Sama sekali, dalam bahasa C, struct / union / enum adalah instruksi makro yang diproses oleh preprocessor bahasa C (jangan salah dengan preprocessor yang memperlakukan "#include" dan lainnya)

jadi:

struct a
{
   int i;
};

struct b
{
   struct a;
   int i;
   int j;
};

struct b dikeluarkan sebagai sesuatu seperti ini:

struct b
{
    struct a
    {
        int i;
    };
    int i;
    int j;
}

jadi, pada waktu kompilasi, ia berevolusi di stack sebagai sesuatu seperti: b: int ai int i int j

itu juga mengapa sulit untuk memiliki struct selfreferent, putaran preprocessor C dalam loop deklarasi yang tidak dapat diakhiri.

typedef adalah specifier tipe, yang berarti hanya proses compiler C dan itu bisa dilakukan seperti yang dia inginkan untuk mengoptimalkan implementasi kode assembler. Itu juga tidak mengeluarkan anggota tipe par bodoh seperti préprocessor lakukan dengan struct tetapi menggunakan algoritma konstruksi referensi yang lebih kompleks, jadi konstruksi seperti:

typedef struct a A; //anticipated declaration for member declaration

typedef struct a //Implemented declaration
{
    A* b; // member declaration
}A;

diizinkan dan berfungsi penuh. Implementasi ini juga memberikan akses ke konversi tipe kompilator dan menghapus beberapa efek penyadap ketika utas eksekusi meninggalkan bidang aplikasi fungsi inisialisasi.

Ini berarti bahwa dalam C typedefs lebih dekat sebagai kelas C ++ daripada struct kesepian.