Aşağıdaki gibi yapılardan oluşan birçok program gördüm

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

elem user;

Neden bu kadar sık ​​ihtiyaç duyuluyor? Belirli bir sebep veya uygulanabilir alan var mı?

Greg Hewgill'in dediği gibi, typedef artık her yere yazmak zorunda olmadığınız anlamına geliyor struct. Bu sadece tuş vuruşlarını kaydetmekle kalmaz, aynı zamanda bir temizleyici daha soyutlama sağladığı için kodu daha temiz hale getirebilir.

Gibi şeyler

typedef struct {
  int x, y;
} Point;

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

"struct" anahtar kelimesini her yerde görmeniz gerekmediğinde daha temiz hale gelir, daha çok kendi dilinizde "Nokta" adı verilen bir tür varmış gibi görünür. Hangi, sonra, typedefsanırım.

Ayrıca, örneğiniz (ve benimki) struct kendisini adlandırmayı ihmal etse de , aslında adlandırmanın opak bir tür sağlamak istediğinizde de yararlı olduğunu unutmayın. Ardından, başlıkta böyle bir kodunuz olur, örneğin:

typedef struct Point Point;

Point * point_new(int x, int y);

ve ardından structuygulama dosyasındaki tanımı sağlayın :

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;
}

Bu son durumda, tanımı başlık dosyasının kullanıcılarından gizlendiği için Noktadan Noktaya değer döndüremezsiniz. Bu, örneğin GTK + 'da yaygın olarak kullanılan bir tekniktir .

GÜNCELLEME Bu typedefgizlenmenin kullanımının structkötü bir fikir olduğu düşünülen C projeleri de vardır , Linux çekirdeği muhtemelen en iyi bilinen projedir. Linus'un öfkeli kelimeleri için Linux Çekirdek Kodlama Türü belgesinin 5. Bölümüne bakın . :) Demek istediğim, soruda "gerekir" belki de sonuçta taş değil.

Kaç kişinin bunu yanlış anlaması şaşırtıcı. LÜTFEN C'ye yapı tanımlamaz, gereksiz olarak büyük C programlarında zaten çok kirli olan küresel ad alanını gereksiz yere kirletir.

Ayrıca, etiket adı olmayan typedef'd yapıları, üstbilgi dosyaları arasında ilişki siparişi vermenin gereksiz nedenlerinden biridir.

Düşünmek:

#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

Böyle bir tanımla, typedefs kullanmadan, bir derleme biriminin tanımına foo.h eklemesi mümkündür FOO_DEF. Eğer yapının 'bar' üyesini kaldırma girişiminde bulunmazsa foo, "bar.h" dosyasını dahil etmeye gerek kalmaz.

Ayrıca, ad alanları etiket adları ile üye adları arasında farklı olduğundan, aşağıdakiler gibi çok okunabilir kodlar yazmak mümkündür:

struct foo *foo;

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

Ad alanları ayrı olduğundan, yapı etiketi adıyla çakışan değişkenlerin adlandırılmasında bir çakışma yoktur.

Kodunuzu korumak zorunda kalırsam, typedef'd yapılarınızı kaldıracağım.

Dan Saks'ın eski bir makalesinden ( http://www.ddj.com/cpp/184403396?pgno=3 ):

Yapıları adlandırmak için C dili kuralları biraz eksantriktir, ancak oldukça zararsızdır. Bununla birlikte, C ++ sınıflarına genişletildiğinde, aynı kurallar hataların taranması için küçük çatlaklar açar.

C harfinde, ad

struct s
    {
    ...
    };

bir etikettir. Etiket adı bir tür adı değildir. Yukarıdaki tanım göz önüne alındığında,

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

C hatalarıdır. Bunları şu şekilde yazmalısınız:

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

Sendikaların ve numaralandırmaların adları da türlerden ziyade etiketlerdir.

C'de, etiketler diğer tüm adlardan farklıdır (işlevler, türler, değişkenler ve numaralandırma sabitleri için). C derleyicileri, diğer tüm adları içeren tablodan fiziksel olarak ayrı değilse kavramsal olarak bir sembol tablosundaki etiketleri korur. Böylece, bir C programının aynı yazılışta aynı yazılışı olan bir etikete ve başka bir ada sahip olması mümkündür. Örneğin,

struct s s;

s değişkeninin s değişkenini bildiren geçerli bir bildirimdir. İyi bir uygulama olmayabilir, ancak C derleyicileri bunu kabul etmelidir. C'nin neden bu şekilde tasarlandığına dair hiçbir gerekçe görmedim. Her zaman bunun bir hata olduğunu düşündüm, ama işte burada.

Birçok programcı (sizinki de dahil) yapı adlarını tür adı olarak düşünmeyi tercih eder, bu nedenle bir typedef kullanarak etiket için bir takma ad tanımlarlar. Örneğin,

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

S'yi, yapıların yerine,

S x;
S *p;

Bir program S'yi hem tür hem de değişken (veya işlev veya numaralandırma sabiti) adı olarak kullanamaz:

S S;    // error

Bu iyi.

Yapı, birleşim veya numaralandırma tanımındaki etiket adı isteğe bağlıdır. Birçok programcı yapı tanımını typedef'e katlar ve aşağıdaki gibi etiketle birlikte dağıtır:

typedef struct
    {
    ...
    } S;

Bağlantılı makalede ayrıca bir C ++ davranışının nasıl typedefince ad gizleme sorunlarına neden olabileceği hakkında bir tartışma vardır . Bu sorunları önlemek için typedef, ilk bakışta gereksiz gibi görünse de, C ++ 'daki sınıflarınız ve yapılarınız için iyi bir fikirdir . C ++ 'da, typedefgizleme adıyla derleyicinin size gizli bir potansiyel sorun kaynağı yerine anlattığı bir hata olur.

Kullanarak typedef yazmak zorunda önü alınır structbu türde bir değişken bildirmek her zaman:

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

Numaraları ve yapıları daima tanımlamak için bir başka iyi neden, bu sorundan kaynaklanır:

enum EnumDef
{
  FIRST_ITEM,
  SECOND_ITEM
};

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

Yapıdaki EnumDef'teki (Enu u mDef) yazım hatası fark ettiniz mi? Bu, hatasız (veya uyarı) olmadan derlenir ve (C Standardının gerçek yorumuna bağlı olarak) doğrudur. Sorun şu ki, benim yapımda yeni (boş) bir numaralandırma tanımı oluşturdum. Ben (tanımlandığı gibi) önceki tanım EnumDef kullanarak değilim.

Bir typdef ile benzer türdeki yazım hataları, bilinmeyen bir türü kullanmak için derleyici hatalarına neden olur:

typedef 
{
  FIRST_ITEM,
  SECOND_ITEM
} EnumDef;

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

DAİMA daktilo tanımlama yapılarını ve numaralandırmalarını savunurdum.

Sadece bazı yazımları kaydetmek için değil (cinas amaçlanan;)) değil, daha güvenli olduğu için.

Linux çekirdeği kodlama stili Bölüm 5 kullanmanın büyük artılarını ve eksilerini (çoğunlukla eksilerini) verir typedef.

Lütfen "vps_t" gibi şeyler kullanmayın.

Yapıları ve işaretçiler için typedef kullanmak bir hatadır . Bir gördüğünüzde

vps_t a;

Kaynakta ne anlama geliyor?

Aksine, diyorsa

struct virtual_container *a;

aslında "a" nın ne olduğunu söyleyebilirsiniz.

Birçok kişi typedef'lerin "okunabilirliğe yardımcı olduğunu" düşünüyor. Öyle değil. Sadece şunlar için yararlıdırlar:

(a) tamamen opak nesneler (burada typedef'in nesnenin ne olduğunu gizlemek için aktif olarak kullanıldığı ).

Örnek: "pte_t" vb. Yalnızca uygun erişimci işlevlerini kullanarak erişebileceğiniz opak nesneler.

NOT! Opaklık ve "erişimci fonksiyonları" kendi başlarına iyi değildir. Onları pte_t gibi şeyler için sahip olmamızın nedeni, orada kesinlikle sıfır portatif olarak erişilebilir bilgi olmasıdır.

(b) "int" ya da "long" olsun , soyutlamanın karışıklığı önlemeye yardımcı olduğu temiz tamsayı türleri .

u8 / u16 / u32, bu kategoriden (d) kategorisine daha iyi uysalar da, mükemmel şekilde ince tip tanımlardır.

NOT! Tekrar - bunun bir nedeni olmalı . Bir şey "imzasız uzun" ise, bunu yapmak için bir neden yok

typedef unsigned long myflags_t;

ancak belirli koşullar altında "imzasız int" ve diğer yapılandırmalar altında "imzasız uzun" olabileceğinin açık bir nedeni varsa, elbette devam edin ve bir typedef kullanın.

(c) tam anlamıyla yazım denetimi için yeni bir tür oluşturmak için seyrek kullandığınızda .

(d) Belirli istisnai durumlarda standart C99 tipleriyle aynı olan yeni tipler.

Gözlerin ve beynin 'uint32_t' gibi standart tiplere alışması kısa bir süre alsa da, bazı insanlar yine de kullanımlarına itiraz ediyorlar.

Bu nedenle, Linux'a özgü 'u8 / u16 / u32 / u64' türlerine ve standart türlerle aynı olan imzalı eşdeğerlerine izin verilir - kendi kodunuzda zorunlu olmamasına rağmen.

Halihazırda bir veya daha fazla tür grubu kullanan mevcut kodu düzenlerken, o koddaki mevcut seçeneklere uymanız gerekir.

(e) Kullanıcı alanında kullanım için güvenli tipler.

Kullanıcı alanı tarafından görülebilen bazı yapılarda, C99 tiplerine gereksinim duymayız ve yukarıdaki 'u32' formunu kullanamayız. Bu nedenle, kullanıcı alanıyla paylaşılan tüm yapılarda __u32 ve benzeri türleri kullanıyoruz.

Belki başka durumlar da vardır, ancak bu kurallardan birini açıkça eşleştiremediğiniz sürece, temelde HİÇBİR ZAMAN asla bir typedef kullanmamak olmalıdır.

Genel olarak, bir imleç veya makul olarak doğrudan erişilebilen öğelere sahip bir yapı hiçbir zaman bir typedef olmamalıdır .

Artıları ve eksileri olduğu ortaya çıkıyor. Yararlı bir bilgi kaynağı "Uzman C Programlama" başlıklı kitaptır ( Bölüm 3 ). Kısaca, C'de birden çok ad alanınız vardır: etiketler, türler, üye adları ve tanımlayıcılar . typedefbir tür için bir takma ad ekler ve bunu etiket ad alanında bulur. Yani,

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

iki şeyi tanımlar. Etiket ad alanında bir Etiket ve tür ad alanında bir Etiket yazın. Yani her ikisini birden yapabilirsiniz Type myTypeve struct Tag myTagType. Yasa dışı struct Type myTypeveya benzeri beyanlar Tag myTagType. Ayrıca, böyle bir bildiride:

typedef Type *Type_ptr;

Tipimize bir işaretçi tanımlıyoruz. Yani eğer beyan edersek:

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

Daha sonra var1, var2ve myTagType1yazın ancak işaretçileri myTagType2değil.

Yukarıda adı geçen kitapta, yalnızca tanımlayıcı yapıların, programcıyı yalnızca struct kelimesini yazmaktan kurtardığı için çok yararlı olmadığı belirtilmektedir. Ancak, diğer birçok C programcısı gibi bir itirazım var. Her ne kadar bazen C'de polimorfizm uygulamak istediğinizde bazı isimleri gizlemek için (bu yüzden çekirdek gibi büyük kod tabanlarında tavsiye edilmez), ayrıntılar için burada çok fazla görünmeye yardımcı olur . Misal:

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

yapabilirsin:

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

Böylece bir dış üyeye (flags yapıya ( MyPipe) iç yapı ( ) ile döküm yoluyla erişebilirsiniz. Benim için, (struct MyWriter_ *) s;bu tür bir işlevsellik yapmak istediğiniz her zaman yapmaktan ziyade, tüm türü yayınlamak daha az kafa karıştırıcıdır . Bu durumlarda, özellikle kodunuzda tekniği yoğun bir şekilde kullanırsanız, kısa referanslar büyük önem taşır.

Son olarak, typedefed türlerinin son yönü, makroların aksine, bunları genişletememesidir. Örneğin, aşağıdakilere sahipsiniz:

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

sonra beyan edebilirsin

unsigned X x; but not
unsigned Y y;

Depolama tanımlayıcıları ( volatileve const) için geçerli olmadığından, bunu yapılar için gerçekten önemsemiyoruz .

İleri bildirimlerin typedef ile bile mümkün olduğunu düşünmüyorum. Struct, enum ve union kullanımı bağımlılıklar (bilir) iki yönlü olduğunda bildirimlerin iletilmesine izin verir.

Stil: C ++ 'da typedef kullanımı oldukça mantıklı. Birden fazla ve / veya değişken parametre gerektiren şablonlarla uğraşırken neredeyse gerekli olabilir. Typedef, adlandırmayı düz tutmaya yardımcı olur.

C programlama dilinde öyle değil. Typedef'in kullanımı çoğunlukla veri yapısı kullanımını gizlemekten başka bir amaca hizmet etmez. Bir veri türünü bildirmek için yalnızca {struct (6), enum (4), union (5)} tuş vuruşlarının sayısı kullanıldığından, yapının takma adı için neredeyse hiç kullanım yoktur. Bu veri türü bir birleşim mi yoksa bir yapı mı? Basit, daktilo edilmemiş bildirimi kullanmak, ne tür olduğunu hemen bilmenizi sağlar.

Linux'un nasıl yazıldığına dikkat ederek bu takma adından kaçınarak saçmalık tipedef getiriyor. Sonuç minimalist ve temiz bir stildir.

Temel bilgilerle başlayalım ve yolumuza devam edelim.

İşte Yapı tanımına bir örnek:

struct point
  {
    int x, y;
  };

İşte adı point isteğe bağlıdır.

Bir Yapı, tanımı sırasında veya sonrasında bildirilebilir.

Tanımlama sırasında bildirme

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

Tanımdan sonra bildirme

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

Şimdi, yukarıdaki son durumu dikkatlice not edin; struct pointkodunuzda daha sonraki bir noktada bu türü oluşturmaya karar verirseniz, bu tür yapıları bildirmek için yazmanız gerekir .

Enter typedef. Programınızda daha sonra aynı planı kullanarak yeni Yapı (Yapı özel bir veri türüdür) oluşturmak typedefistiyorsanız, bazı yazma işlemlerini ilerletebildiğiniz için tanımı sırasında kullanmak iyi bir fikir olabilir.

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

Points first_point, second_point;

Özel türünüzü adlandırırken dikkat edin

Hiçbir şey özel tür adınızın sonunda _t son ekini kullanmanızı engellemez, ancak POSIX standardı standart kitaplık türü adlarını belirtmek için _t sonekinin kullanımını saklı tutar.

(isteğe bağlı olarak) yapıya verdiğiniz ad etiket adı olarak adlandırılır ve belirtildiği gibi kendi içinde bir tür değildir. Türüne ulaşmak için struct önekini gerektirir.

GTK + bir yana, tagname yapı türü için bir typedef gibi yaygın olarak kullanılan bir şey olduğundan emin değilim, bu yüzden tanınan C ++ ve struct anahtar sözcüğünü atlayabilir ve tagname türü adı olarak da kullanabilirsiniz:

    struct MyStruct
    {
      int i;
    };

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

typedef, ko-bağımlı bir veri yapıları seti sağlamayacaktır. Bu typdef ile yapamazsınız:

struct bar;
struct foo;

struct foo {
    struct bar *b;
};

struct bar {
    struct foo *f;
};

Tabii ki her zaman ekleyebilirsiniz:

typedef struct foo foo_t;
typedef struct bar bar_t;

Bunun amacı tam olarak nedir?

A> typdef , veri türleri için daha anlamlı eş anlamlılar oluşturulmasına izin vererek bir programın anlamına ve belgelenmesine yardımcı olur . Ek olarak, bir programı taşınabilirlik sorunlarına (K&R, pg147, C prog lang) göre parametrelendirmeye yardımcı olurlar.

B> bir yapı bir tür tanımlar . Yapılar, tek bir birim olarak kullanım kolaylığı (K&R, pg127, C prog lang.) İçin bir çeşit koleksiyonunun uygun şekilde gruplandırılmasını sağlar.

Bir yapının tip tanımlanması yukarıdaki A'da açıklanmaktadır.

D> Bana göre, yapılar özel türler veya kaplar veya koleksiyonlar veya ad alanları veya karmaşık türlerken, typdef sadece daha fazla takma ad oluşturmak için bir araçtır.

C99 'da çıkıyor typedef gereklidir. Eski, ancak bir çok araç (ala HackRank) saf C uygulaması olarak c99 kullanıyor. Ve burada typedef gereklidir.

Gereksinim değiştiğinde değişmeleri gerektiğini (belki iki C seçeneğine sahip olduklarını) söylemiyorum, sitede röportajlar yapmak için çalışanlarımız SOL olurdu.

'C' programlama dilinde 'typedef' anahtar sözcüğü, bazı nesneler için yeni bir ad bildirmek için kullanılır (struct, array, function..enum type). Örneğin, bir 'struct-s' kullanacağım. 'C' de genellikle 'ana' fonksiyonun dışında bir 'yapı' ilan ederiz. Örneğin:

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);

}

Bir yapı türü kullanmaya her karar verdiğimde bu anahtar kelime 'struct' bir şey 'ad' gerekir. 'Typedef' basitçe bu türü yeniden adlandıracak ve bu yeni adı programımda her istediğimde kullanabiliyorum. Yani kodumuz:

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);

}

Tüm programınızda kullanılacak bazı yerel nesneleriniz varsa (yapı, dizi, değerli) bir 'typedef' kullanarak bir ad verebilirsiniz.

C dilinde, struct / union / enum, C dili önişlemcisi tarafından işlenen makro talimatıdır ("#include" ve diğerlerini tedavi eden önişlemciyle hata yapmayın)

yani :

struct a
{
   int i;
};

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

b yapısı aşağıdaki gibi harcanır:

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

ve böylece, derleme zamanında yığın gibi gelişir: b: int ai int i int j

bu yüzden de kendini ifade eden yapılara sahip olmak zor, C önişlemci sonlandırılamayan bir déclaration döngüsünde.

typedef türü belirleyicidir, yani sadece C derleyicisi tarafından işlenir ve derleyici kod uygulamasını optimize etmek için istediği gibi yapabilir. Ayrıca, önişlemci gibi aptalca yapıları ile aptalca bir tür üyesi harcamak değil, ancak daha karmaşık referans inşaat algoritması kullanın, bu yüzden inşaat gibi:

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

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

izin verilir ve tamamen işlevseldir. Bu uygulama aynı zamanda compilator tipi dönüştürmeye erişim sağlar ve yürütme iş parçacığı başlatma işlevlerinin uygulama alanından ayrıldığında bazı hata efektlerini kaldırır.

Bu, C typedef'lerin C ++ sınıfına yalnız yapılardan daha yakın olduğu anlamına gelir.