ตัวแปรคงที่ระดับฟังก์ชันจะได้รับการจัดสรร / เริ่มต้นเมื่อใด

ฉันค่อนข้างมั่นใจว่าตัวแปรที่ประกาศทั่วโลกได้รับการจัดสรร (และเริ่มต้นถ้ามี) ในเวลาเริ่มโปรแกรม

int globalgarbage;
unsigned int anumber = 42;

แต่สิ่งที่คงที่ที่กำหนดไว้ในฟังก์ชัน?

void doSomething()
{
  static bool globalish = true;
  // ...
}

globalishจัดสรรพื้นที่เมื่อใด ฉันคาดเดาเมื่อรายการเริ่มต้นขึ้น แต่มันเริ่มต้นแล้วด้วยหรือไม่? หรือเริ่มต้นเมื่อdoSomething()ถูกเรียกครั้งแรก?

ฉันสงสัยเกี่ยวกับเรื่องนี้ดังนั้นฉันจึงเขียนโปรแกรมทดสอบต่อไปนี้และรวบรวมด้วย g ++ เวอร์ชัน 4.1.2

include <iostream>
#include <string>

using namespace std;

class test
{
public:
        test(const char *name)
                : _name(name)
        {
                cout << _name << " created" << endl;
        }

        ~test()
        {
                cout << _name << " destroyed" << endl;
        }

        string _name;
};

test t("global variable");

void f()
{
        static test t("static variable");

        test t2("Local variable");

        cout << "Function executed" << endl;
}


int main()
{
        test t("local to main");

        cout << "Program start" << endl;

        f();

        cout << "Program end" << endl;
        return 0;
}

ผลลัพธ์ไม่เป็นไปตามที่ฉันคาดหวัง ตัวสร้างสำหรับวัตถุคงที่ไม่ถูกเรียกจนกว่าจะมีการเรียกใช้ฟังก์ชันครั้งแรก นี่คือผลลัพธ์:

global variable created
local to main created
Program start
static variable created
Local variable created
Function executed
Local variable destroyed
Program end
local to main destroyed
static variable destroyed
global variable destroyed

คำฟุ่มเฟือยที่เกี่ยวข้องบางประการจากมาตรฐาน C ++:

3.6.2 การเริ่มต้นอ็อบเจ็กต์ที่ไม่ใช่โลคัล [basic.start.init]

1

การจัดเก็บสำหรับวัตถุที่มีระยะเวลาการจัดเก็บแบบคงที่ ( basic.stc.static ) จะต้องเริ่มต้นเป็นศูนย์ ( dcl.init ) ก่อนที่การเริ่มต้นอื่น ๆ จะเกิดขึ้น อ็อบเจ็กต์ประเภท POD ( basic.types ) ที่มีระยะเวลาการจัดเก็บแบบคงที่ซึ่งเริ่มต้นด้วยนิพจน์คงที่ ( expr.const ) จะถูกเตรียมใช้งานก่อนที่จะมีการเตรียมใช้งานแบบไดนามิก อ็อบเจ็กต์ของขอบเขตเนมสเปซที่มีระยะเวลาการจัดเก็บแบบคงที่ซึ่งกำหนดไว้ในหน่วยการแปลเดียวกันและการเตรียมใช้งานแบบไดนามิกจะถูกเตรียมใช้งานตามลำดับที่คำจำกัดความปรากฏในหน่วยการแปล [หมายเหตุ: dcl.init.aggr อธิบายลำดับการเริ่มต้นสมาชิกรวม การเริ่มต้นของวัตถุคงท้องถิ่นอธิบายไว้ในstmt.dcl ]

[ข้อความเพิ่มเติมด้านล่างเพิ่มเสรีภาพสำหรับผู้เขียนคอมไพเลอร์]

6.7 ประกาศคำสั่ง [stmt.dcl]

...

4

การเริ่มต้นเป็นศูนย์ ( dcl.init ) ของอ็อบเจ็กต์โลคัลทั้งหมดที่มีระยะเวลาการจัดเก็บแบบคงที่ ( basic.stc.static ) จะดำเนินการก่อนที่จะเริ่มต้นอื่น ๆ อ็อบเจ็กต์โลคัลประเภท POD ( basic.types ) ที่มีระยะเวลาการจัดเก็บแบบคงที่ที่เริ่มต้นด้วยนิพจน์คงที่จะถูกเตรียมใช้งานก่อนที่จะป้อนบล็อกก่อน การใช้งานได้รับอนุญาตให้ทำการกำหนดค่าเริ่มต้นของอ็อบเจ็กต์โลคัลอื่น ๆ ก่อนโดยมีระยะเวลาการจัดเก็บแบบคงที่ภายใต้เงื่อนไขเดียวกับที่การใช้งานได้รับอนุญาตให้เตรียมใช้งานอ็อบเจ็กต์แบบคงที่ด้วยระยะเวลาการจัดเก็บแบบคงที่ในขอบเขตเนมสเปซ ( basic.start.init). มิฉะนั้นวัตถุดังกล่าวจะเริ่มต้นเมื่อการควบคุมครั้งแรกผ่านการประกาศ วัตถุดังกล่าวถือว่าเริ่มต้นเมื่อการเริ่มต้นเสร็จสมบูรณ์ หากการเริ่มต้นออกจากข้อยกเว้นการกำหนดค่าเริ่มต้นจะไม่สมบูรณ์ดังนั้นจะพยายามอีกครั้งในครั้งต่อไปที่การควบคุมเข้าสู่การประกาศ หากการควบคุมเข้าสู่การประกาศซ้ำ (เรียกซ้ำ) ในขณะที่วัตถุกำลังเริ่มต้นพฤติกรรมจะไม่ได้กำหนด [ ตัวอย่าง:

      int foo(int i)
      {
          static int s = foo(2*i);  // recursive call - undefined
          return i+1;
      }

- ตัวอย่างตอนท้าย ]

5

ตัวทำลายสำหรับอ็อบเจ็กต์โลคัลที่มีระยะเวลาการจัดเก็บแบบคงที่จะดำเนินการต่อเมื่อตัวแปรถูกสร้างขึ้น [หมายเหตุ: basic.start.term อธิบายลำดับที่วัตถุโลคัลที่มีระยะเวลาการจัดเก็บแบบคงที่ถูกทำลาย ]

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

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

@Adam: เบื้องหลังการฉีดโค้ดโดยคอมไพเลอร์คือเหตุผลของผลลัพธ์ที่คุณเห็น

ฉันลองทดสอบโค้ดอีกครั้งจากAdam Pierceและเพิ่มอีกสองกรณี: ตัวแปรคงที่ในคลาสและประเภท POD คอมไพเลอร์ของฉันคือ g ++ 4.8.1 ใน Windows OS (MinGW-32) ผลลัพธ์เป็นตัวแปรคงที่ในคลาสจะถือว่าเหมือนกันกับตัวแปรส่วนกลาง ตัวสร้างจะถูกเรียกก่อนเข้าสู่ฟังก์ชันหลัก

• สรุป (สำหรับ g ++, สภาพแวดล้อม Windows):

  1. ตัวแปรทั่วโลกและสมาชิกแบบคงที่ในระดับ : คอนสตรัคเรียกว่าก่อนที่จะเข้าสู่หลักฟังก์ชั่น(1)
  2. ตัวแปรคงที่ภายใน : ตัวสร้างจะถูกเรียกเมื่อการดำเนินการถึงการประกาศในครั้งแรกเท่านั้น
  3. หากตัวแปรคงที่ท้องถิ่นเป็นประเภท PODแล้วก็ยังเริ่มต้นก่อนที่จะเข้าสู่หลักฟังก์ชั่น(1) ตัวอย่างสำหรับประเภท POD: หมายเลข int คงที่ = 10;

(1) : สถานะที่ถูกต้องควรเป็น: "ก่อนเรียกฟังก์ชันใด ๆ จากหน่วยการแปลเดียวกัน" อย่างไรก็ตามพูดง่ายๆตามตัวอย่างด้านล่างนี้ก็คือหน้าที่หลัก

รวม <iostream>

#include < string>

using namespace std;

class test
{
public:
   test(const char *name)
            : _name(name)
    {
            cout << _name << " created" << endl;
    }

    ~test()
    {
            cout << _name << " destroyed" << endl;
    }

    string _name;
    static test t; // static member
 };
test test::t("static in class");

test t("global variable");

void f()
{
    static  test t("static variable");
    static int num = 10 ; // POD type, init before enter main function

    test t2("Local variable");
    cout << "Function executed" << endl;
}

int main()
{
    test t("local to main");
    cout << "Program start" << endl;
    f();
    cout << "Program end" << endl;
    return 0;
 }

ผลลัพธ์:

static in class created
global variable created
local to main created
Program start
static variable created
Local variable created
Function executed
Local variable destroyed
Program end
local to main destroyed
static variable destroyed
global variable destroyed
static in class destroyed

มีใครทดสอบใน Linux env บ้าง?

หรือเริ่มต้นเมื่อ doSomething () ถูกเรียกครั้งแรก?

ใช่แล้ว. สิ่งนี้ช่วยให้คุณเริ่มต้นโครงสร้างข้อมูลที่เข้าถึงได้ทั่วโลกเมื่อมีความเหมาะสมตัวอย่างเช่นภายในบล็อก try / catch เช่นแทนที่จะเป็น

int foo = init(); // bad if init() throws something

int main() {
  try {
    ...
  }
  catch(...){
    ...
  }
}

คุณสามารถเขียน

int& foo() {
  static int myfoo = init();
  return myfoo;
}

และใช้ในบล็อก try / catch ในการโทรครั้งแรกตัวแปรจะเริ่มต้น จากนั้นในการโทรครั้งแรกและครั้งถัดไปค่าของมันจะถูกส่งกลับ (โดยการอ้างอิง)

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

ตัวแปรคงที่ภายในขอบเขตฟังก์ชันจะได้รับการปฏิบัติเหมือนกันขอบเขตเป็นโครงสร้างระดับภาษาเท่านั้น

ด้วยเหตุนี้คุณจึงรับประกันได้ว่าตัวแปรคงที่จะเริ่มต้นเป็น 0 (เว้นแต่คุณจะระบุอย่างอื่น) แทนที่จะเป็นค่าที่ไม่ได้กำหนด

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

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