C/C++
{Back to Index}  Expand All Details on Page

int a = 0;
int b{};
int c = {};
int d = { 0 };
int e; // 不要使用这种方式

int e = 42;
int f{ 42 };
int g = { 42 };
int h( 42 );

int array_1[]{ 1, 2, 3 };       // array of 3 integers
int array_2[5]{};               // array of 5 integers, all elements are initialized to 0
int array_3[5]{ 1, 2, 3 };      // array of 5 integers, first 3 elements are 1, 2, 3, the rest are 0
int array_4[5];                 // array of 5 uninitialized integers (dangerous!)

#include <cstdint>

struct Pod {
    uint64_t a;
    char b[256];
    bool c;
};

int main() {
    Pod pod1{};                 // all fields are zeroed
    Pod pod2 = {};              // all fields are zeroed
    Pod pod3{ 42, "hello" };    // a = 42, b = "hello", c = 0
    Pod pod4{ 42, "hello", true };    // a = 42, b = "hello", c = true
    Pod pod5 = { 42, "hello", true }; // same as above
    Pod pod6 = { .a = 42, .b = "hello", .c = true }; // same as above
}

struct Taxonomist {
    Taxonomist() {
        printf("(no argument)\n");
    }

    Taxonomist(int x) {
        printf("int: %d\n", x);
    }

    Taxonomist(char x) {
        printf("char: %c\n", x);
    }

    Taxonomist(float x) {
        printf("float: %f\n", x);
    }
};

int main() {
    Taxonomist t1;              // (no argument)
    Taxonomist t2{ 'c' };       // char: c
    Taxonomist t3{ 65537 };     // int: 65537
    Taxonomist t4 { 6.02e23f }; // float: 602000000000000000000000
    Taxonomist t5('g');         // char: g
    Taxonomist t6 = { 'l' };    // char: l
    Taxonomist t7{};            // (no argument)
    Taxonomist t8();            // WRONG, 这是个函数声明，这就是要引入大括号初始化语法的一个主要原因，另一个主要原因是 Narrowing conversion
}

struct JohanVanDerSmut {
    bool gold = true;           // equal sign
    int year_of_smelting_accident { 1970 }; // curly braces
    char key_location[8] = { "x-rated" };   // equal sign with curly braces
};

float a{ 1 };
float b{ 2 };
int narrowed(a / b); // narrowing conversion
printf("narrowed: %d\n", narrowed);
int result { a / b }; // Compiler generated warning
printf("result: %d\n", result);

DerivedClass(const DerivedClass& other) : BaseClass(other) {
    // Copy constructor code
}

DerivedClass& operator=(const DerivedClass& other) {
    if (this != &other) {
        // Copy the base class part
        BaseClass::operator=(other);
        // Copy the derived class part
        derivedMember = other.derivedMember;
    }
    return *this;
}

DerivedClass(DerivedClass&& other) noexcept : BaseClass(std::move(other)) {
    // move other's resources to this
}

DerivedClass& operator=(DerivedClass&& other) noexcept {
    if (this == &other) {
        return *this;
    }
    BaseClass::operator=(std::move(other));
    // move other's members to this
    return *this;
}

template <size_t Index, typename T, size_t Length>
T& get(T (&arr)[Length]) {
    static_assert(Index < Length, "Index out of bounds");
    return arr[Index];
}

int arr[] = {1, 2, 3, 4, 5};
std::cout << get<2>(arr) << std::endl; // 3

namespace BroopKidron13::Shaltanc {
    enum class Color {
        Mauve, Pink, Russet
    }
}

int main() {
    using namespace BroopKidron13::Shaltanc::Color;
    const auto shaltanac_grass = Color::Russet;
    if (shaltanac_grass == Color::Russet) {
        printf("The grass is russet\n");
    }
}

#include <cstdio>
#include <stdexcept>

template <typename To, typename From>
struct NarrowCaster {
  To cast(From value) const {
    const auto converted = static_cast<To>(value);
    const auto backwards = static_cast<From>(converted);
    if(value != backwards)
      throw std::runtime_error{ "Narrowed!" };
    return converted;
  }
};

template <typename From>
using short_caster = NarrowCaster<short, From>;

int main() {
  try {
    const short_caster<int> caster;
    const auto cyclic_short = caster.cast(142857);
    printf("cyclic_short: %d\n", cyclic_short);
  } catch(const std::runtime_error& e) {
    printf("Exception: %s\n", e.what());
  }
}

#include <cstdio>
#include <stdexcept>
#include <type_traits>

template <typename T>
auto value_of(T x) {
  if constexpr(std::is_pointer<T>::value) {
    if(!x)
      throw std::runtime_error{ "Null pointer dereference." };
    return *x;
  } else {
    return x;
  }
}

int main() {
  unsigned long level{ 8998 };
  auto level_ptr = &level;
  auto& level_ref = level;
  printf("Power level = %lu\n", value_of(level_ptr));
  ++*level_ptr;
  printf("Power level = %lu\n", value_of(level_ref));
  ++level_ref;
  printf("It's over %lu!\n", value_of(level++));
  try {
    level_ptr = nullptr;
    value_of(level_ptr);
  } catch(const std::exception& e) {
    printf("Exception: %s\n", e.what());
  }
}