Apa yang dilakukan static_assert, dan untuk apa Anda akan menggunakannya?

Bisakah Anda memberi contoh di mana static_assert(...)('C ++ 11') akan menyelesaikan masalah di tangan dengan elegan?

Saya akrab dengan run-time assert(...). Kapan saya harus memilih static_assert(...)daripada biasa assert(...)?

Juga, di dalam boostada yang disebut BOOST_STATIC_ASSERT, apakah sama dengan static_assert(...)?

Dari atas kepala saya...

#include "SomeLibrary.h"

static_assert(SomeLibrary::Version > 2, 
         "Old versions of SomeLibrary are missing the foo functionality.  Cannot proceed!");

class UsingSomeLibrary {
   // ...
};

Dengan asumsi itu SomeLibrary::Versiondideklarasikan sebagai konstanta statis, bukan sebagai #defined (seperti yang diharapkan dalam pustaka C ++).

Berbeda dengan harus benar-benar mengkompilasi SomeLibrarydan kode Anda, hubungan segalanya, dan menjalankan eksekusi hanya kemudian untuk mengetahui bahwa Anda menghabiskan 30 menit kompilasi versi tidak kompatibel SomeLibrary.

@Arak, menanggapi komentar Anda: ya, Anda bisa static_assertduduk di mana saja, dari tampilan itu:

class Foo
{
    public: 
        static const int bar = 3;
};

static_assert(Foo::bar > 4, "Foo::bar is too small :(");

int main()
{ 
    return Foo::bar;
}

$ g ++ --std = c ++ 0x a.cpp
a.cpp: 7: error: pernyataan statis gagal: "Foo :: bar terlalu kecil :("

Penegasan statis digunakan untuk membuat pernyataan pada waktu kompilasi. Ketika pernyataan statis gagal, program tidak dapat dikompilasi. Ini berguna dalam situasi yang berbeda, seperti, misalnya, jika Anda menerapkan beberapa fungsionalitas dengan kode yang sangat bergantung pada unsigned intobjek yang memiliki persis 32 bit. Anda dapat menempatkan pernyataan statis seperti ini

static_assert(sizeof(unsigned int) * CHAR_BIT == 32);

dalam kode Anda. Di platform lain, dengan jenis ukuran yang berbeda unsigned int, kompilasi akan gagal, sehingga menarik perhatian pengembang ke bagian kode yang bermasalah dan menyarankan mereka untuk menerapkan ulang atau memeriksanya kembali.

Untuk contoh lain, Anda mungkin ingin meneruskan beberapa nilai integral sebagai void *pointer ke suatu fungsi (hack, tetapi kadang berguna) dan Anda ingin memastikan bahwa nilai integral akan sesuai dengan pointer

int i;

static_assert(sizeof(void *) >= sizeof i);
foo((void *) i);

Anda mungkin ingin aset charjenis itu ditandatangani

static_assert(CHAR_MIN < 0);

atau pembagian integral dengan nilai negatif membulatkan ke arah nol

static_assert(-5 / 2 == -2);

Dan seterusnya.

Dalam banyak kasus, pernyataan run-time dapat digunakan sebagai pengganti pernyataan statis, tetapi pernyataan run-time hanya berfungsi pada waktu proses dan hanya jika kontrol melewati pernyataan. Karena alasan ini, pernyataan run-time yang gagal mungkin tidak aktif, tidak terdeteksi untuk waktu yang lama.

Tentu saja, ekspresi dalam pernyataan statis harus berupa konstanta waktu kompilasi. Ini tidak bisa menjadi nilai run-time. Untuk nilai run-time Anda tidak punya pilihan lain selain menggunakan yang biasa assert.

Saya menggunakannya untuk memastikan asumsi saya tentang perilaku compiler, header, libs, dan bahkan kode saya sendiri sudah benar. Misalnya di sini saya memverifikasi bahwa struct telah dikemas dengan benar ke ukuran yang diharapkan.

struct LogicalBlockAddress
{
#pragma pack(push, 1)
    Uint32 logicalBlockNumber;
    Uint16 partitionReferenceNumber;
#pragma pack(pop)
};
BOOST_STATIC_ASSERT(sizeof(LogicalBlockAddress) == 6);

Dalam pembungkus kelas stdio.h's fseek(), saya telah mengambil beberapa cara pintas dengan enum Origindan cek bahwa mereka pintas sejajar dengan konstanta yang didefinisikan olehstdio.h

uint64_t BasicFile::seek(int64_t offset, enum Origin origin)
{
    BOOST_STATIC_ASSERT(SEEK_SET == Origin::SET);

Anda harus memilih static_assertlebih assertsaat perilaku didefinisikan pada waktu kompilasi, dan tidak pada saat runtime, seperti contoh yang saya berikan di atas. Contoh di mana hal ini tidak terjadi akan mencakup pemeriksaan parameter dan kode kembali.

BOOST_STATIC_ASSERTadalah makro pra-C ++ 0x yang menghasilkan kode ilegal jika kondisinya tidak terpenuhi. Tujuannya sama, meskipun static_assertsudah terstandarisasi dan dapat memberikan diagnostik compiler yang lebih baik.

BOOST_STATIC_ASSERTadalah pembungkus lintas platform untuk static_assertfungsionalitas.

Saat ini saya menggunakan static_assert untuk menerapkan "Konsep" di kelas.

contoh:

template <typename T, typename U>
struct Type
{
  BOOST_STATIC_ASSERT(boost::is_base_of<T, Interface>::value);
  BOOST_STATIC_ASSERT(std::numeric_limits<U>::is_integer);
  /* ... more code ... */
};

Ini akan menyebabkan kesalahan waktu kompilasi jika salah satu kondisi di atas tidak terpenuhi.

Salah satu kegunaannya static_assertmungkin untuk memastikan bahwa struktur (yang merupakan antarmuka dengan dunia luar, seperti jaringan atau file) persis dengan ukuran yang Anda harapkan. Ini akan menangkap kasus di mana seseorang menambah atau memodifikasi anggota dari struktur tanpa menyadari konsekuensinya. Itu static_assertakan mengambilnya dan memperingatkan pengguna.

Jika tidak ada konsep yang dapat digunakan static_assertuntuk pemeriksaan jenis waktu kompilasi yang sederhana dan dapat dibaca, misalnya, dalam template:

template <class T>
void MyFunc(T value)
{
static_assert(std::is_base_of<MyBase, T>::value, 
              "T must be derived from MyBase");

// ...
}

Ini tidak secara langsung menjawab pertanyaan asli, tetapi membuat studi yang menarik tentang bagaimana menerapkan pemeriksaan waktu kompilasi ini sebelum C ++ 11.

Bab 2 (Bagian 2.1) Desain C ++ Modern oleh Andrei Alexanderscu mengimplementasikan gagasan pernyataan waktu kompilasi seperti ini

template<int> struct CompileTimeError;
template<> struct CompileTimeError<true> {};

#define STATIC_CHECK(expr, msg) \
{ CompileTimeError<((expr) != 0)> ERROR_##msg; (void)ERROR_##msg; } 

Bandingkan makro STATIC_CHECK () dan static_assert ()

STATIC_CHECK(0, COMPILATION_FAILED);
static_assert(0, "compilation failed");

The static_assertdapat digunakan untuk melarang penggunaan deletekata kunci cara ini:

#define delete static_assert(0, "The keyword \"delete\" is forbidden.");

Setiap pengembang C ++ modern mungkin ingin melakukannya jika dia ingin menggunakan pengumpul sampah konservatif dengan hanya menggunakan kelas dan struct yang membebani operator new untuk memanggil fungsi yang mengalokasikan memori pada tumpukan konservatif dari pengumpul sampah konservatif yang dapat diinisialisasi dan dibuat instance-nya dengan menjalankan beberapa fungsi yang melakukan ini di awal mainfungsi.

Misalnya, setiap pengembang C ++ modern yang ingin menggunakan kolektor sampah konservatif Boehm-Demers-Weiser akan mainmenulis di awal fungsi:

GC_init();

Dan di setiap classdan structmembebani dengan operator newcara ini:

void* operator new(size_t size)
{
     return GC_malloc(size);
}

Dan sekarang hal operator deleteitu tidak diperlukan lagi, karena pengumpul sampah konservatif Boehm-Demers-Weiser bertanggung jawab untuk membebaskan dan membatalkan alokasi setiap blok memori saat tidak diperlukan lagi, pengembang ingin melarang deletekata kunci.

Salah satu caranya adalah membebani dengan delete operatorcara ini:

void operator delete(void* ptr)
{
    assert(0);
}

Tetapi ini tidak disarankan, karena pengembang C ++ modern akan tahu bahwa dia salah memanggil delete operatorwaktu berjalan, tetapi ini lebih baik untuk segera mengetahuinya pada waktu kompilasi.

Jadi solusi terbaik untuk skenario ini menurut saya adalah menggunakan static_assertseperti yang ditunjukkan di awal jawaban ini.

Tentu saja ini juga bisa dilakukan BOOST_STATIC_ASSERT, tapi menurut saya itu static_assertlebih baik dan harus lebih selalu disukai.