“ คงที่ const” เทียบกับ“ #define” เทียบกับ“ enum”

ตัวเลือกใดดีกว่าที่จะใช้ในข้อความด้านล่างใน C

static const int var = 5;

หรือ

#define var 5

หรือ

enum { var = 5 };

ขึ้นอยู่กับสิ่งที่คุณต้องการสำหรับค่า คุณ (และคนอื่น ๆ ) ไม่ได้ใช้ตัวเลือกที่สาม:

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

ไม่สนใจปัญหาเกี่ยวกับการเลือกชื่อจากนั้น:

• หากคุณต้องการส่งตัวชี้ไปรอบ ๆ คุณต้องใช้ (1)
• เนื่องจาก (2) เป็นตัวเลือกคุณจึงไม่จำเป็นต้องส่งตัวชี้ไปรอบ ๆ
• ทั้ง (1) และ (3) มีสัญลักษณ์ในตารางสัญลักษณ์ของดีบักเกอร์ซึ่งทำให้การดีบักง่ายขึ้น มีโอกาสมากที่ (2) จะไม่มีสัญลักษณ์ทำให้คุณสงสัยว่ามันคืออะไร
• (1) ไม่สามารถใช้เป็นส่วนข้อมูลสำหรับอาร์เรย์ที่ขอบเขตส่วนกลาง ทั้ง (2) และ (3) สามารถ
• (1) ไม่สามารถใช้เป็นมิติสำหรับอาร์เรย์แบบคงที่ที่ขอบเขตฟังก์ชัน ทั้ง (2) และ (3) สามารถ
• ภายใต้ C99 ทั้งหมดเหล่านี้สามารถใช้สำหรับอาร์เรย์ในเครื่อง ในทางเทคนิคแล้วการใช้ (1) จะบ่งบอกถึงการใช้ VLA (อาเรย์ความยาวแปรผัน) แม้ว่าขนาดที่อ้างอิงโดย 'var' จะถูกกำหนดแน่นอนที่ขนาด 5
• (1) ไม่สามารถใช้ในสถานที่เช่นคำสั่ง switch; ทั้ง (2) และ (3) สามารถ
• (1) ไม่สามารถใช้เพื่อเริ่มต้นตัวแปรสแตติก ทั้ง (2) และ (3) สามารถ
• (2) สามารถเปลี่ยนรหัสที่คุณไม่ต้องการเปลี่ยนแปลงได้เพราะมันถูกใช้โดยตัวประมวลผลล่วงหน้า; ทั้ง (1) และ (3) จะไม่มีผลข้างเคียงที่ไม่คาดคิดเช่นนั้น
• คุณสามารถตรวจสอบได้ว่า (2) ตั้งไว้ในตัวประมวลผลล่วงหน้าหรือไม่ ทั้ง (1) และ (3) ไม่อนุญาตให้ทำเช่นนั้น

ดังนั้นในบริบทส่วนใหญ่ต้องการ 'enum' มากกว่าทางเลือก มิฉะนั้นสัญลักษณ์แสดงหัวข้อย่อยแรกและสุดท้ายมีแนวโน้มที่จะเป็นปัจจัยควบคุม - และคุณต้องคิดให้หนักขึ้นถ้าคุณต้องตอบสนองทั้งสองในครั้งเดียว

หากคุณถามเกี่ยวกับ C ++ คุณจะต้องใช้ตัวเลือก (1) - const แบบคงที่ - ทุกครั้ง

พูด, พูดแบบทั่วไป, พูดทั่วๆไป:

static const

เพราะมันเคารพขอบเขตและเป็นประเภทที่ปลอดภัย

caveat เดียวที่ฉันเห็น: ถ้าคุณต้องการตัวแปรที่อาจกำหนดไว้ในบรรทัดคำสั่ง ยังมีทางเลือก:

#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

เมื่อใดก็ตามที่เป็นไปได้แทนที่จะใช้มาโคร / จุดไข่ปลาให้ใช้ทางเลือกประเภทที่ปลอดภัย

หากคุณจำเป็นต้องใช้แมโครจริงๆ (ตัวอย่างเช่นคุณต้องการ__FILE__หรือ__LINE__) คุณควรตั้งชื่อแมโครของคุณให้ดีขึ้นด้วยความระมัดระวัง: ในแบบแผนการตั้งชื่อ Boost จะแนะนำตัวพิมพ์ใหญ่ทั้งหมดโดยเริ่มจากชื่อโครงการ (ที่นี่ BOOST_ ) ในขณะที่อ่านห้องสมุดคุณจะสังเกตเห็นว่านี่คือ (โดยทั่วไป) ตามด้วยชื่อของพื้นที่เฉพาะ (ไลบรารี) แล้วด้วยชื่อที่มีความหมาย

โดยทั่วไปแล้วจะทำให้ชื่อยาว :)

ใน C โดยเฉพาะ ใน C คำตอบที่ถูกต้องคือใช้#define(หรือถ้าเหมาะสมenum)

ในขณะที่มันมีประโยชน์ที่จะมีการกำหนดขอบเขตและคุณสมบัติการพิมพ์ของconstวัตถุในความเป็นจริงconstวัตถุใน C (เมื่อเทียบกับ C ++) ไม่ใช่ค่าคงที่ที่แท้จริงดังนั้นจึงมักจะไร้ประโยชน์ในกรณีที่ใช้งานได้จริง

ดังนั้นใน C ตัวเลือกควรถูกกำหนดโดยวิธีที่คุณวางแผนที่จะใช้ค่าคงที่ของคุณ ตัวอย่างเช่นคุณไม่สามารถใช้const intวัตถุเป็นcaseป้ายกำกับ (ในขณะที่แมโครจะทำงาน) คุณไม่สามารถใช้const intวัตถุเป็นความกว้างบิตฟิลด์ (ในขณะที่แมโครจะทำงาน) ใน C89 / 90 คุณไม่สามารถใช้constวัตถุเพื่อระบุขนาดอาร์เรย์ (ในขณะที่แมโครทำงานได้) แม้แต่ใน C99 คุณไม่สามารถใช้constวัตถุเพื่อระบุขนาดของอาเรย์เมื่อคุณต้องการอาเรย์ที่ไม่ใช่VLA

หากนี่เป็นสิ่งสำคัญสำหรับคุณก็จะเป็นตัวเลือกของคุณ ส่วนใหญ่เวลาที่คุณจะไม่มีทางเลือก แต่กับการใช้งาน#defineใน C. และอย่าลืมอีกทางเลือกหนึ่งที่ก่อให้เกิดค่าคงที่จริงใน enumC.

ในconstวัตถุC ++ เป็นค่าคงที่ที่แท้จริงดังนั้นใน C ++ มันเกือบจะดีกว่าเสมอที่จะชอบconstชุดย่อย (ไม่จำเป็นต้องระบุอย่างชัดเจนstaticใน C ++)

ความแตกต่างระหว่างstatic constและ#defineคือที่ก่อนหน้านี้ใช้หน่วยความจำและในภายหลังไม่ได้ใช้หน่วยความจำสำหรับการจัดเก็บ ประการที่สองคุณไม่สามารถส่งที่อยู่ของผู้นั้นในขณะที่คุณสามารถส่งที่อยู่ของผู้ที่#define static constที่จริงมันขึ้นอยู่กับสถานการณ์ที่เราอยู่ภายใต้เราต้องเลือกหนึ่งในสองคนนี้ ทั้งคู่อยู่ในสภาพที่ดีที่สุดภายใต้สถานการณ์ที่แตกต่างกัน โปรดอย่าคิดว่าอันนี้ดีกว่าอันอื่น ... :-)

ถ้าเป็นอย่างนั้นเดนนิสริตชี่ จะเป็นคนที่ดีที่สุดคนเดียว ... ฮ่าฮ่าฮ่า ... :-)

ใน C #defineเป็นที่นิยมมากขึ้น คุณสามารถใช้ค่าเหล่านั้นในการประกาศขนาดอาร์เรย์ตัวอย่างเช่น:

#define MAXLEN 5

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

ANSI C ไม่อนุญาตให้คุณใช้static consts ในบริบทนี้เท่าที่ฉันรู้ ใน C ++ คุณควรหลีกเลี่ยงมาโครในกรณีเหล่านี้ คุณสามารถเขียน

const int maxlen = 5;

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

และออกไปstaticเพราะการเชื่อมโยงภายในถูกบอกเป็นนัยโดยconst[ใน C ++ เท่านั้น]

ข้อเสียเปรียบอีกข้อconstใน C คือคุณไม่สามารถใช้ค่าในการเริ่มต้นอื่น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;

แม้สิ่งนี้จะไม่ทำงานกับ const เนื่องจากคอมไพเลอร์ไม่เห็นว่าเป็นค่าคงที่:

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!

ฉันยินดีที่จะใช้พิมพ์constในกรณีเหล่านี้มิฉะนั้น ...

หากคุณสามารถหนีไปstatic constได้มีข้อดีมากมาย มันเป็นไปตามหลักการของขอบเขตปกติสามารถมองเห็นได้ในตัวดีบั๊กและโดยทั่วไปแล้วจะปฏิบัติตามกฎที่ตัวแปรเชื่อฟัง

อย่างไรก็ตามอย่างน้อยในมาตรฐาน C ดั้งเดิมมันคงไม่เป็นจริง หากคุณใช้#define var 5คุณสามารถเขียนint foo[var];เป็นการประกาศ แต่คุณไม่สามารถทำเช่นนั้นได้ (ยกเว้นเป็นส่วนขยายคอมไพเลอร์ "ด้วยstatic const int var = 5;นี่ไม่ใช่กรณีใน C ++ ที่ซึ่งstatic constรุ่นนี้สามารถใช้งานได้ทุกที่ที่เป็น#defineไปได้และฉันเชื่อว่า เป็นกรณีที่มี C99

อย่างไรก็ตามอย่าตั้งชื่อ#defineค่าคงที่ด้วยชื่อตัวพิมพ์เล็ก มันจะแทนที่การใช้ชื่อที่เป็นไปได้ใด ๆ จนกว่าจะสิ้นสุดของหน่วยการแปล ค่าคงที่มาโครควรอยู่ในเนมสเปซของตัวเองอย่างมีประสิทธิภาพซึ่งเป็นตัวพิมพ์ใหญ่ทั้งหมดซึ่งอาจเป็นส่วนนำหน้า

ควรใช้ const แทน #define เสมอ นั่นเป็นเพราะ const ได้รับการดูแลโดยคอมไพเลอร์และ #define โดย preprocessor มันเหมือน #define ตัวเองไม่ได้เป็นส่วนหนึ่งของรหัส (พูดคร่าว ๆ )

ตัวอย่าง:

#define PI 3.1416

คอมไพเลอร์ชื่อสัญลักษณ์ PI อาจไม่สามารถมองเห็นได้ มันอาจจะถูกลบออกโดย preprocessor ก่อนที่จะได้รับรหัสแหล่งแม้แต่คอมไพเลอร์ เป็นผลให้ชื่อ PI อาจไม่ได้รับการป้อนลงในตารางสัญลักษณ์ สิ่งนี้อาจสร้างความสับสนหากคุณได้รับข้อผิดพลาดระหว่างการคอมไพล์ที่เกี่ยวข้องกับการใช้ค่าคงที่เนื่องจากข้อความแสดงข้อผิดพลาดอาจอ้างถึง 3.1416 ไม่ใช่ PI ถ้า PI ถูกกำหนดไว้ในไฟล์ส่วนหัวที่คุณไม่ได้เขียนคุณจะไม่รู้ว่ามาจากไหน 3.1416

ปัญหานี้ยังสามารถครอบตัดในดีบักเกอร์ที่เป็นสัญลักษณ์อีกครั้งเนื่องจากชื่อที่คุณกำลังเขียนโปรแกรมอาจไม่อยู่ในตารางสัญลักษณ์

สารละลาย:

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

#define var 5mystruct.varจะทำให้คุณเดือดร้อนถ้าคุณมีสิ่งที่ต้องการ

ตัวอย่างเช่น,

struct mystruct {
    int var;
};

#define var 5

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

ตัวประมวลผลล่วงหน้าจะแทนที่และรหัสจะไม่คอมไพล์ ด้วยเหตุนี้สไตล์การเขียนโปรแกรมดั้งเดิมแนะนำให้ค่าคงที่ทั้งหมด#defineใช้อักษรตัวใหญ่เพื่อหลีกเลี่ยงความขัดแย้ง

ฉันเขียนโปรแกรมทดสอบอย่างรวดเร็วเพื่อแสดงความแตกต่าง:

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

สิ่งนี้รวบรวมด้วยข้อผิดพลาดและคำเตือนเหล่านี้:

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
        ^

โปรดทราบว่า enum ให้ข้อผิดพลาดเมื่อ define ให้คำเตือน

คำนิยาม

const int const_value = 5;

ไม่ได้กำหนดค่าคงที่เสมอไป คอมไพเลอร์บางตัว (เช่นtcc 0.9.26 ) เพียงจัดสรรหน่วยความจำที่ระบุด้วยชื่อ "const_value" การใช้ตัวระบุ "const_value" คุณไม่สามารถแก้ไขหน่วยความจำนี้ได้ แต่คุณยังสามารถแก้ไขหน่วยความจำโดยใช้ตัวระบุอื่น:

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.

นี่หมายถึงคำจำกัดความ

#define CONST_VALUE 5

เป็นวิธีเดียวที่จะกำหนดค่าคงที่ซึ่งไม่สามารถแก้ไขได้ด้วยวิธีการใด ๆ

แม้ว่าคำถามจะเกี่ยวกับจำนวนเต็ม แต่ก็เป็นที่น่าสังเกตว่า #define และ enums นั้นไร้ประโยชน์หากคุณต้องการโครงสร้างหรือสตริงคงที่ สิ่งเหล่านี้มักจะถูกส่งผ่านไปยังฟังก์ชั่นเป็นตัวชี้ (จำเป็นต้องมีสตริงด้วยโครงสร้างจะมีประสิทธิภาพมากขึ้น)

สำหรับจำนวนเต็มถ้าคุณอยู่ในสภาพแวดล้อมแบบฝังตัวที่มีหน่วยความจำที่ จำกัด มากคุณอาจต้องกังวลเกี่ยวกับที่เก็บค่าคงที่และวิธีการเข้าถึงคอมไพล์ คอมไพเลอร์อาจเพิ่มสอง consts ในเวลาทำงาน แต่เพิ่ม #defines สองครั้งในเวลารวบรวม #define คงที่อาจถูกแปลงเป็นหนึ่งหรือมากกว่าหนึ่ง MOV [ทันที] คำแนะนำซึ่งหมายความว่าค่าคงที่จะถูกเก็บไว้อย่างมีประสิทธิภาพในหน่วยความจำโปรแกรม ค่าคงที่ const จะถูกเก็บไว้ในส่วน. const ในหน่วยความจำข้อมูล ในระบบที่มีสถาปัตยกรรมของ Harvard อาจมีความแตกต่างในด้านประสิทธิภาพและการใช้หน่วยความจำแม้ว่าจะมีขนาดเล็กก็ตาม พวกเขาอาจมีความสำคัญสำหรับการเพิ่มประสิทธิภาพฮาร์ดคอร์ของวงใน

อย่าคิดว่าจะมีคำตอบสำหรับ "ซึ่งดีที่สุดเสมอ" แต่อย่างที่ Matthieu กล่าว

static const

เป็นประเภทที่ปลอดภัย #defineแม้ว่าสัตว์เลี้ยงที่ใหญ่ที่สุดของฉันด้วยคือเมื่อการดีบักในVisual Studioคุณไม่สามารถดูตัวแปร มันทำให้เกิดข้อผิดพลาดที่ไม่สามารถหาสัญลักษณ์ได้

อีกทางเลือกหนึ่ง#defineซึ่งให้การกำหนดขอบเขตที่เหมาะสม แต่มีพฤติกรรมเหมือนค่าคงที่ "ของจริง" คือ "enum" ตัวอย่างเช่น:

enum {number_ten = 10;}

ในหลายกรณีมีประโยชน์ในการกำหนดประเภทที่แจกแจงและสร้างตัวแปรของประเภทเหล่านั้น หากทำเช่นนั้นตัวแก้ไขอาจสามารถแสดงตัวแปรตามชื่อการแจงนับของพวกเขา

ข้อแม้ที่สำคัญอย่างหนึ่งในการทำเช่นนั้น: ใน C ++ ประเภทที่แจกแจงมีความเข้ากันได้ที่ จำกัด กับจำนวนเต็ม ตัวอย่างเช่นโดยค่าเริ่มต้นเราไม่สามารถดำเนินการทางคณิตศาสตร์กับพวกเขา ฉันพบว่าเป็นพฤติกรรมเริ่มต้นที่แปลกประหลาดสำหรับ enums; ในขณะที่มันคงจะดีถ้ามีประเภท "เข้มงวด enum" เนื่องจากความปรารถนาที่จะมี C ++ โดยทั่วไปเข้ากันได้กับ C ฉันคิดว่าพฤติกรรมเริ่มต้นของประเภท "enum" ควรใช้แทนกันได้กับจำนวนเต็ม

ความแตกต่างง่ายๆ:

ณ เวลาประมวลผลล่วงหน้าค่าคงที่จะถูกแทนที่ด้วยค่าของมัน ดังนั้นคุณไม่สามารถใช้โอเปอเรเตอร์ dereference กับ define แต่คุณสามารถใช้โอเปอเรเตอร์ dereference กับตัวแปรได้

อย่างที่คุณคิดสมมุติว่าเร็วขึ้นคงที่ const

ตัวอย่างเช่น:

#define mymax 100

printf("address of constant is %p",&mymax);คุณไม่สามารถทำ

แต่มี

const int mymax_var=100

printf("address of constant is %p",&mymax_var);ที่คุณสามารถทำได้

เพื่อให้ชัดเจนยิ่งขึ้นการกำหนดจะถูกแทนที่ด้วยค่าของมันในขั้นตอนการประมวลผลล่วงหน้าดังนั้นเราจึงไม่ได้เก็บตัวแปรใด ๆ ไว้ในโปรแกรม เรามีโค้ดจากเซ็กเมนต์ข้อความของโปรแกรมที่ใช้การกำหนด

อย่างไรก็ตามสำหรับ const คงที่เรามีตัวแปรที่ได้รับการจัดสรรที่ไหนสักแห่ง สำหรับ gcc const แบบคงที่จะถูกจัดสรรในส่วนข้อความของโปรแกรม

ด้านบนฉันต้องการบอกเกี่ยวกับผู้ดำเนินการอ้างอิงดังนั้นแทนที่การอ้างอิงด้วยการอ้างอิง

เราดูรหัสแอสเซมเบลอร์ที่ผลิตบน MBF16X ... ตัวแปรทั้งสองส่งผลให้มีรหัสเดียวกันสำหรับการดำเนินการทางคณิตศาสตร์ (เช่นเพิ่มทันที)

ดังนั้นจึงconst intเป็นที่ต้องการสำหรับการตรวจสอบประเภทในขณะที่#defineเป็นแบบเก่า อาจเป็นเฉพาะคอมไพเลอร์ ดังนั้นตรวจสอบรหัสแอสเซมเบลอร์ของคุณ

ฉันไม่แน่ใจว่าถ้าฉันถูก แต่ในความเห็นของฉันเรียก#defineค่า d เร็วกว่าการเรียกตัวแปรอื่น ๆ ที่ประกาศตามปกติ (หรือค่า const) เป็นเพราะเมื่อโปรแกรมทำงานและจำเป็นต้องใช้ตัวแปรที่ประกาศตามปกติบางอย่างมันต้องข้ามไปยังตำแหน่งที่แน่นอนในหน่วยความจำเพื่อรับตัวแปรนั้น

ในทางตรงกันข้ามเมื่อใช้#defineค่า d โปรแกรมไม่จำเป็นต้องข้ามไปยังหน่วยความจำที่จัดสรรใด ๆ เพียงใช้ค่า ถ้า#define myValue 7และเรียกโปรแกรมก็จะทำงานตรงเช่นเดียวกับเมื่อมันเป็นเพียงแค่การโทรmyValue7