"Statik sabit" ve "# tanım" vs "enum"

Hangisi C'de aşağıdaki ifadeler arasında kullanmak daha iyidir?

static const int var = 5;

veya

#define var 5

veya

enum { var = 5 };

Değer için neye ihtiyacınız olduğuna bağlıdır. Siz (ve şu ana kadar herkes) üçüncü alternatifi atladınız:

1. static const int var = 5;
2. #define var 5
3. enum { var = 5 };

İsim seçimi ile ilgili sorunları göz ardı ederek:

• Etrafta bir işaretçi geçirmeniz gerekiyorsa (1) kullanmanız gerekir.
• Görünüşe göre (2) bir seçenek olduğu için, işaretçileri geçmenize gerek yok.
• Hem (1) hem de (3) hata ayıklayıcının sembol tablosunda bir simge vardır - bu hata ayıklamayı kolaylaştırır. (2) 'nin bir sembolü olmayacağı ve bunun ne olduğunu merak etmen daha olasıdır.
• (1) küresel kapsamdaki diziler için bir boyut olarak kullanılamaz; hem (2) hem de (3) olabilir.
• (1) işlev kapsamındaki statik diziler için boyut olarak kullanılamaz; hem (2) hem de (3) olabilir.
• C99 altında, bunların tümü yerel diziler için kullanılabilir. Teknik olarak, (1) 'in kullanılması bir VLA'nın (değişken uzunluklu dizi) kullanımını ima eder, ancak' var 'tarafından referans verilen boyut elbette 5 boyutunda sabitlenir.
• (1) anahtar ifadeleri gibi yerlerde kullanılamaz; hem (2) hem de (3) olabilir.
• (1) statik değişkenleri başlatmak için kullanılamaz; hem (2) hem de (3) olabilir.
• (2) önişlemci tarafından kullanıldığı için değiştirilmesini istemediğiniz kodu değiştirebilir; (1) ve (3) 'ün böyle beklenmedik yan etkileri olmayacaktır.
• Ön işlemcide (2) ayarlanmış olup olmadığını tespit edebilirsiniz; ne (1) ne de (3) buna izin vermez.

Yani, çoğu bağlamda, alternatiflere göre 'enum'u tercih edin. Aksi takdirde, ilk ve son mermi noktalarının kontrol edici faktörler olması muhtemeldir - ve her ikisini de aynı anda tatmin etmeniz gerekiyorsa daha fazla düşünmeniz gerekir.

C ++ hakkında soru soruyorsanız, (1) seçeneğini - statik sabit - her seferinde kullanırsınız.

Genel konuşma:

static const

Çünkü kapsama saygı duyar ve tip güvenlidir.

Görebildiğim tek uyarı: değişkenin komut satırında tanımlanmasını istiyorsanız. Hala bir alternatif var:

#ifdef VAR // Very bad name, not long enough, too general, etc..
  static int const var = VAR;
#else
  static int const var = 5; // default value
#endif

Mümkün olduğunda, makrolar / üç nokta yerine, güvenli bir alternatif kullanın.

Gerçekten bir makroya (örneğin, istediğiniz __FILE__veya __LINE__) ihtiyacınız varsa, makronuzu ÇOK dikkatli bir şekilde adlandırmanız daha iyi olur: Adlandırma kuralında Boost , projenin adından başlayarak tüm büyük harfleri önerir (burada BOOST_ ), kitaplığı incelerken bunun (genellikle) ardından belirli bir alanın (kitaplığın) ardından anlamlı bir adla geldiğini göreceksiniz.

Genellikle uzun isimler yapar :)

C olarak, özellikle? C'de doğru cevap: kullanın #define(veya uygunsa,enum )

Bir constnesnenin kapsam ve yazma özelliklerine sahip olmak faydalı olsa da, gerçekteconst C'deki nesnelerde (C ++ yerine) gerçek sabitler sabit değildir ve bu nedenle çoğu pratik durumda genellikle işe yaramaz.

Bu nedenle, C'de seçim, sabitinizi nasıl kullanmayı planladığınıza göre belirlenmelidir. Örneğin, bir const intnesneyi caseetiket olarak kullanamazsınız (makro çalışırken). Bir const intnesneyi bit alanı genişliği olarak kullanamazsınız (makro çalışırken). C89 / 90'da constbir dizi boyutu belirtmek için bir nesne kullanamazsınız (bir makro çalışırken). C99'da bile, VLAconst olmayan bir öğeye ihtiyacınız olduğunda bir dizi boyutu belirtmek için bir nesneyi kullanamazsınız .

Bu sizin için önemliyse, seçiminizi belirler. Çoğu zaman, kullanmaktan başka seçeneğiniz olmaz#define C'de başka seçeneğiniz olmayacaktır. Ve C - 'de gerçek sabitler üreten başka bir alternatifi unutmayın enum.

C ++ constnesnelerinde gerçek sabitler vardır, bu yüzden C ++ 'da constvaryantı tercih etmek neredeyse her zaman daha iyidir ( staticC ++' da açıkça gerek yoktur ).

Arasındaki fark static const ve #defineolduğu önceki kullanımları bellek ve depolama için daha sonra kullanmaz bellek. İkinci olarak, bir #defineadresin adresini geçiremezken, a static const. Aslında, hangi koşul altında olduğumuza bağlı olarak, bu ikisi arasından birini seçmemiz gerekiyor. Her ikisi de farklı koşullar altında en iyi durumdadır. Lütfen birinin diğerinden daha iyi olduğunu varsaymayın ... :-)

Durum böyle olsaydı, Dennis Ritchie en iyisini yalnız tutacaktır ... hahaha ... :-)

C'de #defineçok daha popüler. Bu değerleri dizi boyutlarını bildirmek için kullanabilirsiniz, örneğin:

#define MAXLEN 5

void foo(void) {
   int bar[MAXLEN];
}

ANSI C static constbildiğim kadarıyla bu bağlamda kullanmanıza izin vermiyor . C ++ 'da bu durumlarda makrolardan kaçınmalısınız. Yazabilirsin

const int maxlen = 5;

void foo() {
   int bar[maxlen];
}

ve hatta staticiç bağlantı constzaten [sadece C ++ ile] ima edildiği için bile dışarıda kalır .

constC'nin bir başka dezavantajı , değeri bir başkasını başlatırken kullanamamanızdır const.

static int const NUMBER_OF_FINGERS_PER_HAND = 5;
static int const NUMBER_OF_HANDS = 2;

// initializer element is not constant, this does not work.
static int const NUMBER_OF_FINGERS = NUMBER_OF_FINGERS_PER_HAND 
                                     * NUMBER_OF_HANDS;

Derleyici sabit olarak görmediğinden bu bile bir const ile çalışmaz:

static uint8_t const ARRAY_SIZE = 16;
static int8_t const lookup_table[ARRAY_SIZE] = {
    1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16}; // ARRAY_SIZE not a constant!

constBu durumlarda yazılan kullanmaktan mutluluk duyarım , aksi takdirde ...

Eğer ondan kurtulabilirsen, static const , bir çok avantajı var. Normal kapsam ilkelerine uyar, bir hata ayıklayıcıda görünür ve genellikle değişkenlerin uyduğu kurallara uyar.

Bununla birlikte, en azından orijinal C standardında, aslında bir sabit değildir. Eğer kullanırsanız #define var 5, yazabilir int foo[var];bir deklarasyon olarak, ancak bir derleyici uzantısı" olarak haricinde (bunu yapamaz static const int var = 5;. Bu ++, C durum böyle değildir static constversiyonu her yerde kullanılabilir#define versiyonu kutu ve ben buna inanıyorum C99 için de geçerlidir.

Bununla birlikte, asla bir #definesabiti küçük harfli isimle adlandırmayın. Çeviri biriminin sonuna kadar bu adın olası kullanımını geçersiz kılacaktır. Makro sabitleri, geleneksel olarak tüm büyük harfler, belki de bir önek ile kendi ad alanı etkili bir şekilde olmalıdır.

#Define yerine const kullanmak DAİMA tercih edilir. Çünkü const derleyici tarafından işlenir ve #define önişlemci tarafından işlenir. Bu #define kendisi kodun bir parçası değildir (kabaca konuşursak).

Misal:

#define PI 3.1416

PI sembolik ismi derleyiciler tarafından asla görülemez; kaynak kod bir derleyiciye ulaşmadan önce önişlemci tarafından kaldırılabilir. Sonuç olarak, sembol tablosuna PI adı girilemeyebilir. Sabitin kullanımını içeren derleme sırasında bir hata alırsanız bu kafa karıştırıcı olabilir, çünkü hata mesajı PI değil 3.1416'ya işaret edebilir. PI, yazmadığınız bir başlık dosyasında tanımlanmış olsaydı, 3.1416'nın nereden geldiğine dair hiçbir fikriniz olmazdı.

Bu sorun sembolik bir hata ayıklayıcıda da ortaya çıkabilir, çünkü yine programladığınız ad sembol tablosunda olmayabilir.

Çözüm:

const double PI = 3.1416; //or static const...

#define var 5gibi şeyleriniz varsa size sorun çıkarır mystruct.var.

Örneğin,

struct mystruct {
    int var;
};

#define var 5

int main() {
    struct mystruct foo;
    foo.var = 1;
    return 0;
}

Önişlemci onun yerini alacak ve kod derlenmeyecektir. Bu nedenle, geleneksel kodlama stili, tüm sabit #defines'lerin çatışmayı önlemek için büyük harfler kullanmasını önerir .

Bir farkı göstermek için hızlı test programı yazdım:

#include <stdio.h>

enum {ENUM_DEFINED=16};
enum {ENUM_DEFINED=32};

#define DEFINED_DEFINED 16
#define DEFINED_DEFINED 32

int main(int argc, char *argv[]) {

   printf("%d, %d\n", DEFINED_DEFINED, ENUM_DEFINED);

   return(0);
}

Bu, aşağıdaki hatalar ve uyarılarla derlenir:

main.c:6:7: error: redefinition of enumerator 'ENUM_DEFINED'
enum {ENUM_DEFINED=32};
      ^
main.c:5:7: note: previous definition is here
enum {ENUM_DEFINED=16};
      ^
main.c:9:9: warning: 'DEFINED_DEFINED' macro redefined [-Wmacro-redefined]
#define DEFINED_DEFINED 32
        ^
main.c:8:9: note: previous definition is here
#define DEFINED_DEFINED 16
        ^

Define bir uyarı verdiğinde enum'un hata verdiğini unutmayın.

Tanım

const int const_value = 5;

her zaman sabit bir değer tanımlamaz. Bazı derleyiciler (örneğin tcc 0.9.26 ) sadece "const_value" adıyla tanımlanan belleği ayırır. "Const_value" tanımlayıcısını kullanarak bu belleği değiştiremezsiniz. Ancak yine de belleği başka bir tanımlayıcı kullanarak değiştirebilirsiniz:

const int const_value = 5;
int *mutable_value = (int*) &const_value;
*mutable_value = 3;
printf("%i", const_value); // The output may be 5 or 3, depending on the compiler.

Bu tanım

#define CONST_VALUE 5

hiçbir şekilde değiştirilemeyen sabit bir değer tanımlamanın tek yoludur.

Her ne kadar soru tamsayılarla ilgili olsa da, sabit bir yapıya veya dizgiye ihtiyacınız varsa #define ve enums'un işe yaramaz olduğunu belirtmek gerekir. Bunların her ikisi de genellikle işaretçi olarak işlevlere geçirilir. (Dizelerle gereklidir; yapılarla çok daha verimlidir.)

Tamsayılara gelince, çok sınırlı belleğe sahip gömülü bir ortamdaysanız, sabitin nerede depolandığı ve ona erişimin nasıl derlendiği konusunda endişelenmeniz gerekebilir. Derleyici çalışma zamanında iki const ekleyebilir, ancak derleme zamanında iki #define ekleyebilir. Bir #define sabiti bir veya daha fazla MOV [acil] komutuna dönüştürülebilir, bu sabitin program belleğinde etkili bir şekilde saklandığı anlamına gelir. Bir const sabiti, veri belleğindeki .const bölümünde saklanır. Harvard mimarisine sahip sistemlerde, küçük olmalarına rağmen performans ve bellek kullanımında farklılıklar olabilir. İç döngülerin sert çekirdek optimizasyonu için önemli olabilirler.

"Her zaman en iyisi" için bir cevap olduğunu düşünmeyin, ancak Matthieu'nun dediği gibi

static const

güvenli tiptir. #defineBununla birlikte , en büyük evcil hayvanım , Visual Studio'da hata ayıklama sırasında değişkeni izleyememeniz. Sembolün bulunamaması hatası verir.

Bu arada, #defineuygun kapsam belirleme sağlayan ancak "gerçek" sabit gibi davranan bir alternatif "enum" dur. Örneğin:

enum {number_ten = 10;}

Çoğu durumda, numaralandırılmış türleri tanımlamak ve bu türlerden değişkenler oluşturmak yararlıdır; bu yapılırsa, hata ayıklayıcılar numaralandırma adlarına göre değişkenleri görüntüleyebilir.

Bununla birlikte, bununla ilgili önemli bir uyarı: C ++ 'da, numaralandırılmış türlerin tamsayılarla sınırlı uyumluluğu vardır. Örneğin, varsayılan olarak, bunlarda aritmetik yapılamaz. Ben enums için meraklı bir varsayılan davranış olduğunu düşünüyorum; "sıkı enum" türü olması güzel olurdu, C ++ genellikle C ile uyumlu olma arzusu göz önüne alındığında, bir "enum" türü varsayılan davranış tamsayı ile değiştirilebilir olması gerektiğini düşünüyorum.

Basit bir fark:

Ön işleme zamanında sabit, değeri ile değiştirilir. Bu nedenle, bir tanımlamaya dereference operatörünü uygulayamazsınız, ancak dereference operatörünü bir değişkene uygulayabilirsiniz.

Tahmin edeceğiniz gibi, tanım statik sabitten daha hızlıdır.

Örneğin:

#define mymax 100

yapamazsın printf("address of constant is %p",&mymax);.

Ama sahip olmak

const int mymax_var=100

yapabilirsin printf("address of constant is %p",&mymax_var);.

Daha açık olmak gerekirse, tanım, ön işleme aşamasında değeri ile değiştirilir, bu nedenle programda depolanan herhangi bir değişkenimiz yoktur. Sadece tanımın kullanıldığı programın metin bölümündeki koda sahibiz.

Ancak, statik sabit için bir yere tahsis edilen bir değişkenimiz var. Gcc için, statik sabit programın metin bölümüne ayrılır.

Yukarıda, referans operatörü hakkında bilgi vermek istedim, bu yüzden referansı referansla değiştirin.

MBF16X üzerinde üretilen montajcı koduna baktık ... Her iki varyant da aritmetik işlemler için aynı kodla sonuçlanır (örneğin, ADD Immediate).

Yani const intiken tip kontrolü için tercih edilmektedir #defineeski tarzıdır. Belki derleyiciye özgüdür. Ürettiğiniz montajcı kodunu kontrol edin.

Ben haklı olup olmadığından emin değilim ama benim görüşüme göre #defined değeri çağırmak herhangi bir normalde bildirilen değişken (veya const değeri) çağırmak çok daha hızlıdır. Program çalışırken ve normal olarak bildirilen bir değişken kullanması gerektiğinde, bu değişkeni almak için bellekte tam bir yere atlaması gerekir.

Tersine, #defined değerini kullandığında , programın ayrılmış bir belleğe atlaması gerekmez, sadece değeri alır. Eğer #define myValue 7ve program çağırıyorsa myValue, sadece aradığı zamanki gibi davranır 7.