init_seg pragmainit_seg pragma

C++ özelC++ Specific

Başlangıç kodunun yürütüldüğü sırayı etkileyen bir anahtar sözcük veya kod bölümü belirtir.Specifies a keyword or code section that affects the order in which startup code is executed.

SyntaxSyntax

#pragma init_seg( { compiler | lib | user | "bölüm-adı" [ , Func-Name ]} )#pragma init_seg( { compiler | lib | user | "section-name" [ , func-name ] } )

AçıklamalarRemarks

Koşullar segmenti ve bölümü Bu makalede aynı anlama sahiptir.The terms segment and section have the same meaning in this article.

Genel statik nesneleri başlatmak için kod bazen gerekli olduğundan, nesneleri ne zaman oluþturabileceğinize belirtmeniz gerekir.Because code is sometimes required to initialize global static objects, you must specify when to construct the objects. Özellikle, init_seg pragma dinamik bağlantı kitaplıkları (dll 'ler) veya başlatma gerektiren kitaplıklarda kullanılması önemlidir.In particular, it's important to use the init_seg pragma in dynamic-link libraries (DLLs), or in libraries that require initialization.

Seçenekleri init_seg pragma şunlardır:The options to the init_seg pragma are:

compiler
Microsoft C çalışma zamanı kitaplığı başlatması için ayrılmıştır.Reserved for Microsoft C run-time library initialization. Bu gruptaki nesneler önce oluşturulur.Objects in this group are constructed first.

lib
Üçüncü taraf sınıf kitaplığı satıcılarının başlatmaları için kullanılabilir.Available for third-party class-library vendors' initializations. Bu gruptaki nesneler, hariç işaretlendiklerden sonra compiler , ancak başkalarından sonra oluşturulur.Objects in this group are constructed after the ones marked as compiler, but before any others.

user
Herhangi bir kullanıcı tarafından kullanılabilir.Available to any user. Bu gruptaki nesneler son olarak oluşturulur.Objects in this group are constructed last.

Bölüm-adısection-name
Başlatma bölümünün açık belirtimine izin verir.Allows explicit specification of the initialization section. Kullanıcı tarafından belirtilen bölüm adı içindeki nesneler örtülü olarak oluşturulmamış.Objects in a user-specified section-name aren't implicitly constructed. Ancak, adresleri bölüm adı tarafından adlandırılan bölümüne yerleştirilir.However, their addresses are placed in the section named by section-name.

Verdiğiniz bölüm adı , bu modüldeki öğesinden sonra bildirildiği genel nesneleri oluşturacak yardımcı işlevlere işaretçiler içerir pragma .The section-name you give will contain pointers to helper functions that will construct the global objects declared after the pragma in that module.

Bölüm oluştururken kullanmamanız gerekadların bir listesi için, bkz /SECTION ..For a list of names you shouldn't use when creating a section, see /SECTION.

Func-adıfunc-name
Program çıktığında yerine çağrılacak işlevi belirtir atexit .Specifies a function to be called in place of atexit when the program exits. Bu yardımcı işlev ayrıca atexit genel nesne için yıkıcıya yönelik bir işaretçi ile çağırır.This helper function also calls atexit with a pointer to the destructor for the global object. Formunda bir işlev tanımlayıcısı belirtirseniz pragma ,If you specify a function identifier in the pragma of the form,

int __cdecl myexit (void (__cdecl *pf)(void))

ardından işleviniz C çalışma zamanı kitaplığı 'nın yerine çağırılır atexit .then your function will be called instead of the C run-time library's atexit. Nesneleri yok etmeye hazırsanız çağrılacak yıkıcılarının bir listesini oluşturmanızı sağlar.It allows you to build a list of the destructors to call when you're ready to destroy the objects.

Başlatma işlemini erteetmeniz gerekiyorsa (örneğin, bir DLL 'de), Bölüm adını açık olarak belirtmeyi tercih edebilirsiniz.If you need to defer initialization (for example, in a DLL) you may choose to specify the section name explicitly. Kodunuzun ardından her statik nesne için oluşturucuları çağırması gerekir.Your code must then call the constructors for each static object.

Değiştirme için tanımlayıcı etrafında hiç teklif yok atexit .There are no quotes around the identifier for the atexit replacement.

Nesneleriniz, diğer yönergeler tarafından tanımlanan bölümlere yerleştirilmeye devam edecektir XXX_seg pragma .Your objects will still be placed in the sections defined by the other XXX_seg pragma directives.

Modülde belirtilen nesneler C çalışma zamanı tarafından otomatik olarak başlatılmaz.The objects that are declared in the module aren't automatically initialized by the C run-time. Kodunuzun başlatmayı yapması gerekmez.Your code has to do the initialization.

Varsayılan olarak, init_seg bölümler salt okunurdur.By default, init_seg sections are read only. Bölüm adı ise .CRT , derleyici, okuma, yazma olarak işaretlenmiş olsa bile özniteliği sessizce salt yazılır olarak değiştirir.If the section name is .CRT, the compiler silently changes the attribute to read only, even if it's marked as read, write.

init_seg Bir çeviri biriminde birden çok kez belirtemezsiniz.You can't specify init_seg more than once in a translation unit.

Nesneniz, kodda açıkça tanımlanmış bir Kullanıcı tanımlı oluşturucuya sahip olmasa da, derleyici sizin için bir tane oluşturabilir.Even if your object doesn't have a user-defined constructor, one explicitly defined in code, the compiler may generate one for you. Örneğin, sanal tablo işaretçilerini bağlamak için bir tane oluşturabilir.For example, it may create one to bind v-table pointers. Gerektiğinde, kodunuz derleyici tarafından oluşturulan oluşturucuyu çağırır.When needed, your code calls the compiler-generated constructor.

ÖrnekExample

// pragma_directive_init_seg.cpp
#include <stdio.h>
#pragma warning(disable : 4075)

typedef void (__cdecl *PF)(void);
int cxpf = 0;   // number of destructors we need to call
PF pfx[200];    // pointers to destructors.

int myexit (PF pf) {
   pfx[cxpf++] = pf;
   return 0;
}

struct A {
   A() { puts("A()"); }
   ~A() { puts("~A()"); }
};

// ctor & dtor called by CRT startup code
// because this is before the pragma init_seg
A aaaa;

// The order here is important.
// Section names must be 8 characters or less.
// The sections with the same name before the $
// are merged into one section. The order that
// they are merged is determined by sorting
// the characters after the $.
// InitSegStart and InitSegEnd are used to set
// boundaries so we can find the real functions
// that we need to call for initialization.

#pragma section(".mine$a", read)
__declspec(allocate(".mine$a")) const PF InitSegStart = (PF)1;

#pragma section(".mine$z",read)
__declspec(allocate(".mine$z")) const PF InitSegEnd = (PF)1;

// The comparison for 0 is important.
// For now, each section is 256 bytes. When they
// are merged, they are padded with zeros. You
// can't depend on the section being 256 bytes, but
// you can depend on it being padded with zeros.

void InitializeObjects () {
   const PF *x = &InitSegStart;
   for (++x ; x < &InitSegEnd ; ++x)
      if (*x) (*x)();
}

void DestroyObjects () {
   while (cxpf>0) {
      --cxpf;
      (pfx[cxpf])();
   }
}

// by default, goes into a read only section
#pragma init_seg(".mine$m", myexit)

A bbbb;
A cccc;

int main () {
   InitializeObjects();
   DestroyObjects();
}
A()
A()
A()
~A()
~A()
~A()

Ayrıca bkz.See also

Pragma yönergeleri ve __pragma ve _Pragma anahtar sözcükleriPragma directives and the __pragma and _Pragma keywords