C++ de-alienation / 祛魅

notes on c++ sanity checks; This is not about how to use c++ ; instead this is about what’s different and how does xyz work under the hood.

main reference:

• A nice tutorial/cheatsheet https://www.learncpp.com
• explains vtable and virtual functions https://pabloariasal.github.io/2017/06/10/understanding-virtual-tables/
• modern c features https://github.com/AnthonyCalandra/modern-c-features
• modern c++ features https://github.com/AnthonyCalandra/modern-cpp-features

Table of Contents

• type casting
• L/R-value
  • in C
  • in C++
• move semantics and rvalue reference
• class
• overloading
• virtual function and vtable
• attributes
• constexpr
• MISC
  • nullptr
  • user defined literals

§§ type casting

https://stackoverflow.com/questions/332030/when-should-static-cast-dynamic-cast-const-cast-and-reinterpret-cast-be-used

More semantics than C “take this address and interpret it as xyz”

• static_cast: can be used for any type cast that is allowed implicitly; or any type to void, or any conversion that can be reversed.
• reinterpret_cast: dangerous: casting a type directly to another, no guarantee.
• dynamic_cast: for polymorphism. Cast a pointer to a class down/up the hierarchy
• const_cast: remove or add const to a variable
• (type) value (c style cast)
• type(value) (function-style cast)

§§ L/R-value

SRC: https://www.gnu.org/software/c-intro-and-ref/manual/html_node/Lvalues.html SRC: https://en.cppreference.com/w/cpp/language/value_category

l/r-values in CLang are not necessarily on the “left/right side of assignment”, the naming is for historical reasons (CPL language).

§§§ in C

L-Values an expression that identifies a memory space that holds a value.

• a variable
• a pointer dereference expression using *
• structure field reference using . or ->
• array-element reference using [...], if the array is an lvalue
• etc.

§§§ in C++

each expression belongs to exactly one of the three value categories:

• pvalue: (“pure” rvalue)
• xvalue: (“eXpiring” value)
• lvalue: a gavlue that is not an xvalue
• (gvalue): (“generalized” lvalue), an expression whose evaluation determines the identity of an object or function

§§ move semantics and rvalue reference

https://www.codeproject.com/Articles/453022/The-new-Cplusplus-11-rvalue-reference-and-why-you

• rvalue reference (C++11): T&&. return an object by value without making a copy. //// TODO ////

§§ class

§§ overloading

§§ virtual function and vtable

• https://www.geeksforgeeks.org/virtual-function-cpp/
• https://pabloariasal.github.io/2017/06/10/understanding-virtual-tables/

Virtual Function

a member function that is declared within a base class and is re-defined (overridden) by a derived class. (And a vtable will be created for the class); virtual functions ensure that the correct function is called for an object, regardless of the type of reference (or pointer) used for that function call.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

// example from
// https://pabloariasal.github.io/2017/06/10/understanding-virtual-tables/

#include <iostream>

class Base
{
public:
  ~Base(){ std::cout << "Destroying base" << std::endl; }
  // making the base destructor virtual resolves the problem bellow.
  // virtual ~Base(){ std::cout << "Destroying base" << std::endl; }
};

class Derived : public Base
{
public:
  Derived(int number) { /* SNIP */ }

  ~Derived()
  {
    std::cout << "Destroying derived" << std::endl;
    delete some_resource_;
  }

private:
  int* some_resource_;
};

int main()
{
  Base* p = new Derived(5);
  // since delete is called upon a pointer to Base, the base destructor is
  // called. This is wrong !
  delete p;
}

§§ attributes

1

[[ noreturn ]] void f() {}

§§ constexpr

expressions that are “possibly” evaluated by compiler at compile time.

1
2
3

constexpr int f(int x) {
    return x + 1;
}

(“possible” .. you mean it’s not a guarantee?)

§§ MISC

• declare base class desctructor as virtual
• decltype
• Temporary materialization

§§§ nullptr

https://github.com/AnthonyCalandra/modern-cpp-features/blob/master/CPP11.md#nullptr

1
2
3
4

void foo(int);
void foo(char*);
foo(NULL); // error -- ambiguous
foo(nullptr); // calls foo(char*)

nullptr can not be converted into inregral types except bool

§§§ user defined literals

https://github.com/AnthonyCalandra/modern-cpp-features/blob/master/CPP11.md#nullptr

1
2
3
4
5

// `unsigned long long` parameter required for integer literal.
long long operator "" _celsius(unsigned long long tempCelsius) {
  return std::llround(tempCelsius * 1.8 + 32);
}
24_celsius; // == 75