Mengapa penggunaan alokasi () tidak dianggap praktik yang baik?

alloca()mengalokasikan memori pada stack daripada pada heap, seperti pada kasus malloc(). Jadi, ketika saya kembali dari rutinitas, memori itu dibebaskan. Jadi, sebenarnya ini memecahkan masalah saya membebaskan memori yang dialokasikan secara dinamis. Membebaskan memori yang dialokasikan melalui malloc()adalah sakit kepala utama dan jika entah bagaimana terlewatkan mengarah ke semua jenis masalah memori.

Mengapa penggunaan alloca()berkecil hati meskipun fitur di atas?

Jawabannya ada di sana di manhalaman (setidaknya di Linux ):

RETURN VALUE Fungsi Alokasi () mengembalikan pointer ke awal ruang yang dialokasikan. Jika alokasi menyebabkan stack overflow, perilaku program tidak ditentukan.

Yang tidak mengatakan itu tidak boleh digunakan. Salah satu proyek OSS yang saya kerjakan menggunakannya secara luas, dan selama Anda tidak menyalahgunakannya ( allocanilai-nilai yang sangat besar), tidak apa-apa. Setelah Anda melewati tanda "beberapa ratus byte", sekarang saatnya untuk menggunakan mallocdan berteman. Anda mungkin masih mendapatkan kegagalan alokasi, tetapi setidaknya Anda akan memiliki beberapa indikasi kegagalan alih-alih hanya meniup tumpukan.

Salah satu bug paling berkesan yang saya miliki adalah hubungannya dengan fungsi inline yang digunakan alloca. Itu memanifestasikan dirinya sebagai stack overflow (karena mengalokasikan pada stack) pada titik-titik acak dari eksekusi program.

Dalam file header:

void DoSomething() {
   wchar_t* pStr = alloca(100);
   //......
}

Dalam file implementasi:

void Process() {
   for (i = 0; i < 1000000; i++) {
     DoSomething();
   }
}

Jadi yang terjadi adalah DoSomethingfungsi iniler kompiler dan semua alokasi stack terjadi di dalam Process()fungsi dan dengan demikian meledakkan stack. Dalam pembelaan saya (dan saya bukan orang yang menemukan masalah; Saya harus pergi dan menangis ke salah satu pengembang senior ketika saya tidak bisa memperbaikinya), itu tidak lurus alloca, itu adalah salah satu dari konversi string ATL makro.

Jadi pelajarannya adalah - jangan gunakan allocadalam fungsi yang Anda pikir mungkin diuraikan.

Pertanyaan lama tetapi tidak ada yang menyebutkan bahwa itu harus diganti dengan array panjang variabel.

char arr[size];

dari pada

char *arr=alloca(size);

Itu di C99 standar dan ada sebagai ekstensi kompiler di banyak kompiler.

Alokasi () sangat berguna jika Anda tidak dapat menggunakan variabel lokal standar karena ukurannya perlu ditentukan saat runtime dan Anda benar - benar dapat menjamin bahwa pointer yang Anda dapatkan dari Alokasi () TIDAK akan pernah digunakan setelah fungsi ini kembali .

Anda bisa cukup aman jika Anda

• jangan kembalikan pointer, atau apapun yang mengandung itu.
• jangan menyimpan pointer dalam struktur apa pun yang dialokasikan pada heap
• jangan biarkan utas lainnya menggunakan pointer

Bahaya sebenarnya datang dari kemungkinan bahwa orang lain akan melanggar kondisi ini beberapa waktu kemudian. Dengan mengingat hal itu, sangat bagus untuk meneruskan buffer ke fungsi yang memformat teks ke dalamnya :)

Seperti disebutkan dalam posting newsgroup ini , ada beberapa alasan mengapa menggunakan allocabisa dianggap sulit dan berbahaya:

• Tidak semua dukungan kompiler alloca.
• Beberapa kompiler menginterpretasikan perilaku yang diinginkan secara allocaberbeda, sehingga portabilitas tidak dijamin bahkan di antara kompiler yang mendukungnya.
• Beberapa implementasi bersifat buggy.

Satu masalah adalah itu bukan standar, meskipun didukung secara luas. Hal lain dianggap sama, saya selalu menggunakan fungsi standar daripada ekstensi kompiler umum.

masih mengalokasikan penggunaan tidak dianjurkan, mengapa?

Saya tidak melihat konsensus seperti itu. Banyak pro kuat; beberapa kontra:

• C99 menyediakan array panjang variabel, yang sering digunakan secara istimewa sebagai notasi lebih konsisten dengan array panjang tetap dan keseluruhan intuitif
• banyak sistem memiliki lebih sedikit memori / alamat-ruang yang tersedia untuk stack daripada yang mereka lakukan untuk heap, yang membuat program sedikit lebih rentan terhadap kelelahan memori (melalui stack overflow): ini dapat dilihat sebagai hal yang baik atau buruk - satu alasan tumpukan tidak secara otomatis menumbuhkan cara tumpukan adalah untuk mencegah program yang tidak terkendali memiliki dampak negatif yang sama besar pada seluruh mesin
• ketika digunakan dalam lingkup yang lebih lokal (seperti a whileatau forloop) atau dalam beberapa lingkup, memori menumpuk per iterasi / ruang lingkup dan tidak dirilis sampai fungsi keluar: ini kontras dengan variabel normal yang didefinisikan dalam lingkup struktur kontrol (misalnya for {int i = 0; i < 2; ++i) { X }akan menumpukalloca memori yang diminta pada X, tetapi memori untuk array berukuran tetap akan didaur ulang per iterasi).
• kompiler modern biasanya tidak inlineberfungsi yang memanggil alloca, tetapi jika Anda memaksa mereka makaalloca akan terjadi dalam konteks pemanggil (yaitu tumpukan tidak akan dirilis sampai pemanggil kembali)
• dahulu kala alloca beralih dari fitur non-portable / hack ke ekstensi standar, tetapi beberapa persepsi negatif mungkin bertahan
• seumur hidup terikat pada lingkup fungsi, yang mungkin cocok atau tidak sesuai dengan programmer lebih baik daripada mallockontrol eksplisit
• harus menggunakan mallocpemikiran mendorong tentang deallokasi - jika itu dikelola melalui fungsi wrapper (misalnya WonderfulObject_DestructorFree(ptr)), maka fungsi tersebut menyediakan titik untuk implementasi operasi pembersihan (seperti menutup deskriptor file, membebaskan pointer internal atau melakukan logging) tanpa perubahan eksplisit ke klien kode: kadang model yang bagus untuk diadopsi secara konsisten
  • dalam gaya pemrograman pseudo-OO ini, itu wajar untuk menginginkan sesuatu seperti WonderfulObject* p = WonderfulObject_AllocConstructor();- itu mungkin ketika "constructor" adalah fungsi mallocmemori yang dikembalikan (karena memori tetap dialokasikan setelah fungsi mengembalikan nilai untuk disimpan dalam p), tetapi tidak jika "konstruktor" menggunakanalloca
    • versi makro dari WonderfulObject_AllocConstructorbisa mencapai ini, tetapi "makro jahat" di mana mereka dapat saling bertentangan dan kode non-makro dan membuat substitusi yang tidak diinginkan dan akibatnya sulit didiagnosis masalah
  • freeoperasi yang hilang dapat dideteksi oleh ValGrind, Purify dll. tetapi panggilan "destruktor" yang hilang tidak dapat dideteksi sama sekali - satu manfaat yang sangat lemah dalam hal penegakan penggunaan yang dimaksudkan; beberapa alloca()implementasi (seperti GCC) menggunakan makro inline alloca(), jadi substitusi runtime dari perpustakaan diagnostik penggunaan memori tidak mungkin seperti itu untuk malloc/ realloc/ free(misalnya pagar listrik)
• beberapa implementasi memiliki masalah halus: misalnya, dari manual Linux:

  Pada banyak sistem, alokasi () tidak dapat digunakan di dalam daftar argumen pemanggilan fungsi, karena ruang tumpukan dicadangkan oleh alokasi () akan muncul di tumpukan di tengah ruang untuk argumen fungsi.

Saya tahu pertanyaan ini ditandai C, tetapi sebagai seorang programmer C ++ saya pikir saya akan menggunakan C ++ untuk menggambarkan utilitas potensial dari alloca: kode di bawah ini (dan di sini di ideone ) menciptakan vektor pelacakan jenis polimorfik berukuran berbeda yang dialokasikan stack (dengan seumur hidup terikat dengan fungsi return) daripada tumpukan dialokasikan.

#include <alloca.h>
#include <iostream>
#include <vector>

struct Base
{
    virtual ~Base() { }
    virtual int to_int() const = 0;
};

struct Integer : Base
{
    Integer(int n) : n_(n) { }
    int to_int() const { return n_; }
    int n_;
};

struct Double : Base
{
    Double(double n) : n_(n) { }
    int to_int() const { return -n_; }
    double n_;
};

inline Base* factory(double d) __attribute__((always_inline));

inline Base* factory(double d)
{
    if ((double)(int)d != d)
        return new (alloca(sizeof(Double))) Double(d);
    else
        return new (alloca(sizeof(Integer))) Integer(d);
}

int main()
{
    std::vector<Base*> numbers;
    numbers.push_back(factory(29.3));
    numbers.push_back(factory(29));
    numbers.push_back(factory(7.1));
    numbers.push_back(factory(2));
    numbers.push_back(factory(231.0));
    for (std::vector<Base*>::const_iterator i = numbers.begin();
         i != numbers.end(); ++i)
    {
        std::cout << *i << ' ' << (*i)->to_int() << '\n';
        (*i)->~Base();   // optionally / else Undefined Behaviour iff the
                         // program depends on side effects of destructor
    }
}

Semua jawaban lainnya benar. Namun, jika hal yang ingin Anda alokasikan menggunakan alloca()cukup kecil, saya pikir itu adalah teknik bagus yang lebih cepat dan lebih nyaman daripada menggunakan malloc()atau sebaliknya.

Dengan kata lain, alloca( 0x00ffffff )itu berbahaya dan cenderung menyebabkan meluap, persis sebanyak apa char hugeArray[ 0x00ffffff ];adanya. Berhati-hatilah dan masuk akal dan Anda akan baik-baik saja.

Banyak jawaban menarik untuk pertanyaan "lama" ini, bahkan beberapa jawaban yang relatif baru, tetapi saya tidak menemukan yang menyebutkan ini ....

Ketika digunakan dengan benar dan dengan hati-hati, penggunaan yang konsisten alloca() (mungkin di seluruh aplikasi) untuk menangani alokasi panjang variabel yang kecil (atau C99 VLA, jika tersedia) dapat menyebabkan pertumbuhan tumpukan keseluruhan yang lebih rendah daripada implementasi yang setara dengan menggunakan array lokal besar dengan panjang tetap . Jadi alloca()mungkin baik untuk tumpukan Anda jika Anda menggunakannya dengan hati-hati.

Saya menemukan kutipan itu di .... OK, saya membuat kutipan itu. Tapi sungguh, pikirkan tentang itu ....

@j_random_hacker sangat benar dalam komentarnya di bawah jawaban lain: Menghindari penggunaan yang alloca()mendukung array lokal berukuran besar tidak membuat program Anda lebih aman dari stack overflow (kecuali jika kompiler Anda sudah cukup tua untuk memungkinkan inlining fungsi yang digunakan alloca()dalam hal ini Anda harus tingkatkan, atau kecuali jika Anda menggunakan alloca()loop dalam, dalam hal ini Anda harus ... tidak menggunakan alloca()loop dalam).

Saya telah bekerja di lingkungan desktop / server dan sistem embedded. Banyak sistem tertanam tidak menggunakan tumpukan sama sekali (mereka bahkan tidak menautkan dukungan untuk itu), untuk alasan yang mencakup persepsi bahwa memori yang dialokasikan secara dinamis adalah jahat karena risiko kebocoran memori pada aplikasi yang tidak pernah pernah reboot selama bertahun-tahun pada suatu waktu, atau pembenaran yang lebih masuk akal bahwa memori dinamis berbahaya karena tidak dapat diketahui secara pasti bahwa suatu aplikasi tidak akan pernah memecah tumpukannya ke titik kehabisan memori palsu. Jadi programmer yang tertanam dibiarkan dengan beberapa alternatif.

alloca() (atau VLA) mungkin alat yang tepat untuk pekerjaan itu.

Saya telah melihat waktu & waktu lagi di mana seorang programmer membuat buffer yang dialokasikan stack "cukup besar untuk menangani setiap kasus yang mungkin". Dalam pohon panggilan yang sangat bersarang, penggunaan berulang pola (anti -?) Mengarah ke penggunaan tumpukan berlebihan. (Bayangkan pohon panggilan sedalam 20 level, di mana pada setiap level karena alasan yang berbeda, fungsinya secara membabi buta mengalokasikan buffer 1024 byte "hanya untuk aman" ketika umumnya hanya akan menggunakan 16 atau kurang dari itu, dan hanya di sangat kasus yang jarang dapat menggunakan lebih banyak.) Alternatif adalah menggunakanalloca()atau VLA dan hanya mengalokasikan ruang stack sebanyak yang dibutuhkan fungsi Anda, untuk menghindari membebani stack secara tidak perlu. Mudah-mudahan ketika satu fungsi di pohon panggilan membutuhkan alokasi yang lebih besar dari normal, yang lain di pohon panggilan masih menggunakan alokasi kecil normal mereka, dan keseluruhan penggunaan tumpukan aplikasi secara signifikan lebih kecil daripada jika setiap fungsi secara membabi buta mengalokasikan buffer lokal .

Tetapi jika Anda memilih untuk menggunakan alloca()...

Berdasarkan jawaban lain pada halaman ini, tampaknya VLA harus aman (mereka tidak menambah alokasi tumpukan jika dipanggil dari dalam satu loop), tetapi jika Anda menggunakan alloca(), berhati-hatilah untuk tidak menggunakannya di dalam loop, dan buatlah Pastikan fungsi Anda tidak dapat digarisbawahi jika ada kemungkinan ia dipanggil dalam loop fungsi lain.

Semua orang sudah menunjukkan hal besar yang berpotensi perilaku tidak terdefinisi dari stack overflow, tetapi saya harus menyebutkan bahwa lingkungan Windows memiliki mekanisme yang bagus untuk menangkap ini menggunakan pengecualian terstruktur (SEH) dan halaman penjaga. Karena tumpukan hanya tumbuh sesuai kebutuhan, halaman penjaga ini berada di area yang tidak terisi. Jika Anda mengalokasikan ke dalamnya (dengan meluap tumpukan) pengecualian dilemparkan.

Anda dapat menangkap pengecualian SEH ini dan memanggil _resetstkoflw untuk mengatur ulang tumpukan dan melanjutkan dengan cara merry. Itu tidak ideal tapi ini mekanisme lain untuk setidaknya tahu ada yang tidak beres ketika barang itu mengenai kipas. * nix mungkin memiliki sesuatu yang mirip yang tidak saya sadari.

Saya sarankan membatasi ukuran alokasi maksimum Anda dengan membungkus alokasi dan melacaknya secara internal. Jika Anda benar-benar hardcore tentang hal itu, Anda bisa melempar beberapa ruang lingkup penjaga di bagian atas fungsi Anda untuk melacak alokasi alokasi dalam lingkup fungsi dan kewarasan memeriksa ini terhadap jumlah maksimum yang diizinkan untuk proyek Anda.

Selain itu, selain tidak memungkinkan alokasi memori tidak menyebabkan fragmentasi memori yang cukup penting. Saya tidak berpikir alokasi adalah praktik yang buruk jika Anda menggunakannya secara cerdas, yang pada dasarnya berlaku untuk semuanya. :-)

Alokasi () bagus dan efisien ... tetapi juga sangat rusak.

• broken scope behavior (fungsi lingkup alih-alih ruang lingkup blok)
• gunakan tidak konsisten dengan malloc ( mengalokasikan -tunjuk pointer tidak boleh dibebaskan, untuk selanjutnya Anda harus melacak dari mana pointer Anda berasal dari gratis () hanya yang Anda dapatkan dengan malloc () )
• perilaku buruk ketika Anda juga menggunakan inlining (ruang lingkup kadang-kadang pergi ke fungsi penelepon tergantung apakah callee inline atau tidak).
• tidak ada pemeriksaan batas stack
• perilaku yang tidak terdefinisi jika terjadi kegagalan (tidak mengembalikan NULL seperti malloc ... dan apa arti kegagalan karena tidak memeriksa batas tumpukan pula ...)
• bukan standar ansi

Dalam kebanyakan kasus, Anda dapat menggantinya menggunakan variabel lokal dan ukuran majorant. Jika digunakan untuk objek besar, meletakkannya di tumpukan biasanya merupakan ide yang lebih aman.

Jika Anda benar-benar membutuhkannya C Anda dapat menggunakan VLA (tidak ada vla di C ++, terlalu buruk). Mereka jauh lebih baik daripada alokasi () mengenai perilaku dan konsistensi ruang lingkup. Seperti yang saya lihat, VLA adalah semacam alokasi () yang dibuat benar.

Tentu saja struktur lokal atau array menggunakan majorant dari ruang yang dibutuhkan masih lebih baik, dan jika Anda tidak memiliki alokasi heap majorant menggunakan plain malloc () mungkin waras. Saya tidak melihat kasus penggunaan yang waras di mana Anda benar-benar membutuhkan alokasi () atau VLA.

Inilah alasannya:

char x;
char *y=malloc(1);
char *z=alloca(&x-y);
*z = 1;

Bukan berarti siapa pun akan menulis kode ini, tetapi argumen ukuran yang Anda sampaikan allocahampir pasti berasal dari semacam input, yang bisa bertujuan jahat untuk membuat program Anda menjadi allocasesuatu yang besar seperti itu. Lagi pula, jika ukurannya tidak berdasarkan input atau tidak memiliki kemungkinan besar, mengapa Anda tidak mendeklarasikan buffer lokal berukuran kecil dan berukuran tetap?

Hampir semua kode menggunakan alloca dan / atau C99 vlas memiliki bug serius yang akan menyebabkan crash (jika Anda beruntung) atau kompromi privilege (jika Anda tidak seberuntung itu).

Saya tidak berpikir ada yang menyebutkan ini: Penggunaan alokasi dalam suatu fungsi akan menghalangi atau menonaktifkan beberapa optimasi yang dapat diterapkan dalam fungsi, karena kompiler tidak dapat mengetahui ukuran bingkai tumpukan fungsi.

Sebagai contoh, optimasi umum oleh kompiler C adalah untuk menghilangkan penggunaan frame pointer dalam suatu fungsi, akses frame dibuat relatif terhadap stack pointer sebagai gantinya; jadi ada satu register lagi untuk penggunaan umum. Tetapi jika alokasi disebut di dalam fungsi, perbedaan antara sp dan fp tidak akan diketahui untuk bagian dari fungsi, sehingga optimasi ini tidak dapat dilakukan.

Mengingat kelangkaan penggunaannya, dan statusnya yang teduh sebagai fungsi standar, perancang kompiler sangat mungkin menonaktifkan pengoptimalan apa pun yang dapat menyebabkan masalah dengan pengalokasian, jika perlu lebih dari sedikit upaya untuk membuatnya berfungsi dengan pengalokasian.

UPDATE: Karena array lokal panjang variabel telah ditambahkan ke C, dan karena ini menyajikan masalah pembuatan kode yang sangat mirip dengan kompiler sebagai alokasi, saya melihat bahwa 'kelangkaan penggunaan dan status teduh' tidak berlaku untuk mekanisme yang mendasarinya; tapi saya masih akan curiga bahwa penggunaan salah satu alokasi atau VLA cenderung kompromi pembuatan kode dalam fungsi yang menggunakannya. Saya akan menerima umpan balik dari desainer kompiler.

Satu perangkap dengan allocaitu yang longjmpmemundurkannya.

Artinya, jika Anda menyimpan konteks dengan setjmp, maka allocabeberapa memori, maka longjmpke konteksnya, Anda mungkin kehilangan allocamemori. Penunjuk tumpukan kembali ke tempatnya semula sehingga memori tidak lagi dicadangkan; jika Anda memanggil suatu fungsi atau melakukan yang lain alloca, Anda akan mengalahkan yang asli alloca.

Untuk memperjelas, apa yang saya maksudkan secara khusus di sini adalah situasi di mana longjmptidak kembali dari fungsi di mana allocaterjadi! Sebaliknya, fungsi menyimpan konteks dengan setjmp; kemudian mengalokasikan memori dengan allocadan akhirnya longjmp terjadi pada konteks itu. allocaMemori fungsi itu tidak semuanya dibebaskan; hanya semua memori yang dialokasikan sejak setjmp. Tentu saja, saya berbicara tentang perilaku yang diamati; tidak ada persyaratan seperti itu yang didokumentasikanalloca yang saya tahu.

Fokus dalam dokumentasi biasanya pada konsep bahwa allocamemori dikaitkan dengan aktivasi fungsi , bukan dengan blok apa pun; bahwa banyak pemanggilan allocahanya mengambil lebih banyak memori tumpukan yang semuanya dilepaskan ketika fungsi berakhir. Tidak begitu; memori sebenarnya terkait dengan konteks prosedur. Ketika konteksnya dipulihkan longjmp, demikian juga allocakeadaan sebelumnya . Ini adalah konsekuensi dari register penunjuk tumpukan itu sendiri yang digunakan untuk alokasi, dan juga (tentu saja) disimpan dan dipulihkan di jmp_buf.

Kebetulan, ini, jika bekerja seperti itu, menyediakan mekanisme yang masuk akal untuk secara sengaja membebaskan memori yang dialokasikan bersama alloca.

Saya telah menemukan ini sebagai penyebab utama bug.

Sebuah tempat alloca()yang sangat berbahaya daripada malloc()kernel - kernel dari sistem operasi tipikal memiliki ruang stack berukuran tetap yang dikodekan ke dalam salah satu header-nya; itu tidak sefleksibel tumpukan aplikasi. Melakukan panggilan ke alloca()dengan ukuran yang tidak beralasan dapat menyebabkan kernel mogok. Kompiler tertentu memperingatkan penggunaan alloca()(dan bahkan VLA dalam hal ini) di bawah opsi-opsi tertentu yang harus dinyalakan saat menyusun kode kernel - di sini, lebih baik untuk mengalokasikan memori di heap yang tidak diperbaiki oleh batas hard-coded.

Jika Anda secara tidak sengaja menulis di luar blok yang dialokasikan dengan alloca(karena buffer overflow misalnya), maka Anda akan menimpa alamat kembali fungsi Anda, karena yang itu terletak "di atas" pada tumpukan, yaitu setelah blok yang dialokasikan.

Konsekuensi dari ini adalah dua kali lipat:

1. Program akan crash secara spektakuler dan tidak mungkin untuk mengetahui mengapa atau di mana crash (stack kemungkinan besar akan lepas ke alamat acak karena frame pointer yang ditimpa).

2. Itu membuat buffer overflow berkali-kali lebih berbahaya, karena pengguna jahat dapat membuat muatan khusus yang akan diletakkan di tumpukan dan karenanya dapat berakhir dieksekusi.

Sebaliknya, jika Anda menulis di luar blok di heap Anda "hanya" mendapatkan korupsi tumpukan. Program ini mungkin akan berhenti secara tak terduga tetapi akan melepaskan tumpukan dengan benar, sehingga mengurangi kemungkinan eksekusi kode berbahaya.

Sayangnya yang benar-benar luar biasa alloca()hilang dari tcc yang hampir luar biasa. Gcc memang punya alloca().

1. Itu menabur benih kehancurannya sendiri. Dengan pengembalian sebagai destruktor.

2. Seperti malloc()itu mengembalikan pointer tidak valid pada gagal yang akan segfault pada sistem modern dengan MMU (dan mudah-mudahan restart yang tanpa).

3. Tidak seperti variabel otomatis, Anda dapat menentukan ukuran saat dijalankan.

Ini bekerja dengan baik dengan rekursi. Anda dapat menggunakan variabel statis untuk mencapai sesuatu yang mirip dengan rekursi ekor dan menggunakan hanya beberapa yang lain meneruskan info ke setiap iterasi.

Jika Anda mendorong terlalu dalam, Anda dijamin segfault (jika Anda memiliki MMU).

Catatan yang malloc()menawarkan tidak lebih karena mengembalikan NULL (yang juga akan segfault jika ditugaskan) ketika sistem kehabisan memori. Yaitu yang dapat Anda lakukan adalah jaminan atau hanya mencoba menetapkannya dengan cara apa pun.

Untuk menggunakan malloc()saya menggunakan global dan menetapkannya NULL. Jika pointer bukan NULL saya membebaskannya sebelum saya gunakan malloc().

Anda juga dapat menggunakan realloc()sebagai kasus umum jika ingin menyalin data yang ada. Anda perlu memeriksa pointer sebelum bekerja jika Anda akan menyalin atau menyatukan setelahrealloc() .

3.2.5.2 Keuntungan dari alokasi

Proses hanya memiliki jumlah ruang stack yang terbatas - jauh lebih sedikit daripada jumlah memori yang tersedia malloc().

Dengan menggunakan alloca()Anda secara dramatis meningkatkan peluang Anda untuk mendapatkan kesalahan Stack Overflow (jika Anda beruntung, atau crash yang tidak dapat dijelaskan jika Anda tidak).

Tidak terlalu cantik, tetapi jika kinerja benar-benar penting, Anda dapat mengalokasikan beberapa ruang di stack.

Jika Anda sekarang sudah ukuran maksimum memori memblokir kebutuhan Anda dan Anda ingin terus memeriksa melimpah, Anda bisa melakukan sesuatu seperti:

void f()
{
    char array_on_stack[ MAX_BYTES_TO_ALLOCATE ];
    SomeType *p = (SomeType *)array;

    (...)
}

Fungsi alokasi sangat bagus dan semua penentang hanya menyebarkan FUD.

void foo()
{
    int x = 50000; 
    char array[x];
    char *parray = (char *)alloca(x);
}

Array dan parray adalah PERSIS sama dengan risiko yang sama PERSIS. Mengatakan satu lebih baik daripada yang lain adalah pilihan sintaksis, bukan pilihan teknis.

Adapun untuk memilih variabel tumpukan vs variabel tumpukan, ada banyak keuntungan untuk program yang berjalan lama menggunakan tumpukan lebih dari tumpukan untuk variabel dengan masa hidup in-scope. Anda menghindari tumpukan tumpukan dan Anda bisa menghindari menumbuhkan ruang proses Anda dengan ruang tumpukan yang tidak digunakan (tidak dapat digunakan). Anda tidak perlu membersihkannya. Anda dapat mengontrol alokasi tumpukan pada proses.

Kenapa ini buruk?

Sebenarnya, alokasi tidak dijamin untuk menggunakan tumpukan. Memang, implementasi alokasi gcc-2.95 mengalokasikan memori dari heap menggunakan malloc itu sendiri. Juga implementasi yang bermasalah, dapat menyebabkan kebocoran memori dan beberapa perilaku yang tidak terduga jika Anda menyebutnya di dalam blok dengan penggunaan goto lebih lanjut. Tidak, untuk mengatakan bahwa Anda seharusnya tidak pernah menggunakannya, tetapi beberapa kali mengalokasikan mengarah ke lebih banyak overhead daripada yang dikeluarkan darinya.

IMHO, alokasi dianggap praktik buruk karena semua orang takut melelahkan batas ukuran tumpukan.

Saya belajar banyak dengan membaca utas ini dan beberapa tautan lainnya:

• /unix/63742/what-is-automatic-stack-expansion
• Batas alokasi tumpukan untuk program pada mesin Linux 32 bit
• ulimit -s

Saya menggunakan dialokasikan terutama untuk membuat file C biasa saya dapat dikompilasi di msvc dan gcc tanpa perubahan, gaya C89, tidak ada #ifdef _MSC_VER, dll.

Terima kasih ! Utas ini membuat saya mendaftar ke situs ini :)

Menurut pendapat saya, alokasi (), jika tersedia, harus digunakan hanya dengan cara terbatas. Sangat mirip dengan penggunaan "goto", cukup banyak orang yang beralasan memiliki keengganan yang kuat tidak hanya untuk penggunaan, tetapi juga keberadaan, alokasi ().

Untuk penggunaan tertanam, di mana ukuran tumpukan diketahui dan batas dapat dikenakan melalui konvensi dan analisis pada ukuran alokasi, dan di mana kompiler tidak dapat ditingkatkan untuk mendukung C99 +, penggunaan alokasi () baik-baik saja, dan saya sudah diketahui menggunakannya.

Ketika tersedia, VLA mungkin memiliki beberapa keunggulan dibandingkan dengan alokasi (): Kompilator dapat menghasilkan pemeriksaan batas tumpukan yang akan menangkap akses di luar batas ketika akses gaya array digunakan (saya tidak tahu apakah ada kompiler yang melakukan ini, tetapi ia dapat dilakukan), dan analisis kode dapat menentukan apakah ekspresi akses array dibatasi dengan benar. Perhatikan bahwa, dalam beberapa lingkungan pemrograman, seperti otomotif, peralatan medis, dan avionik, analisis ini harus dilakukan bahkan untuk array ukuran tetap, baik otomatis (pada tumpukan) dan alokasi statis (global atau lokal).

Pada arsitektur yang menyimpan data dan mengembalikan alamat / frame pointer pada stack (dari apa yang saya ketahui, semuanya), setiap variabel yang dialokasikan stack dapat berbahaya karena alamat variabel dapat diambil, dan nilai input yang tidak dicentang mungkin mengizinkan segala macam kerusakan.

Portabilitas kurang menjadi perhatian di ruang tertanam, namun itu adalah argumen yang baik terhadap penggunaan alokasi () di luar keadaan yang dikendalikan dengan cermat.

Di luar ruang yang disematkan, saya telah menggunakan Alokasi () sebagian besar di dalam fungsi logging dan pemformatan untuk efisiensi, dan dalam pemindai leksikal non-rekursif, di mana struktur sementara (dialokasikan menggunakan Alokasi () dibuat selama Tokenisasi dan klasifikasi, kemudian terus-menerus objek (dialokasikan melalui malloc ()) diisi sebelum fungsi kembali.Penggunaan alokasi () untuk struktur sementara yang lebih kecil sangat mengurangi fragmentasi ketika objek persisten dialokasikan.

Sebagian besar jawaban di sini sebagian besar tidak tepat: ada alasan mengapa menggunakan _alloca() berpotensi lebih buruk daripada hanya menyimpan benda besar di tumpukan.

Perbedaan utama antara penyimpanan otomatis dan _alloca()bahwa yang terakhir menderita masalah (serius) tambahan: blok yang dialokasikan tidak dikontrol oleh kompiler , jadi tidak ada cara bagi kompiler untuk mengoptimalkan atau mendaur ulangnya.

Membandingkan:

while (condition) {
    char buffer[0x100]; // Chill.
    /* ... */
}

dengan:

while (condition) {
    char* buffer = _alloca(0x100); // Bad!
    /* ... */
}

Masalah dengan yang terakhir harus jelas.

Saya tidak berpikir bahwa ada orang yang menyebutkan ini, tetapi mengalokasikan juga memiliki beberapa masalah keamanan yang serius belum tentu hadir dengan malloc (meskipun masalah ini juga muncul dengan susunan array berbasis, dinamis atau tidak). Karena memori dialokasikan pada stack, buffer overflows / underflow memiliki konsekuensi yang jauh lebih serius daripada hanya dengan malloc.

Secara khusus, alamat pengirim untuk suatu fungsi disimpan pada stack. Jika nilai ini rusak, kode Anda dapat dibuat untuk pergi ke wilayah memori yang dapat dieksekusi. Compiler berusaha keras untuk membuat ini sulit (khususnya dengan mengacak tata letak alamat). Namun, ini jelas lebih buruk dari sekadar stack overflow karena kasus terbaik adalah SEGFAULT jika nilai pengembalian rusak, tetapi juga bisa mulai mengeksekusi sepotong memori acak atau dalam kasus terburuk beberapa wilayah memori yang membahayakan keamanan program Anda .