Language

Collaboration diagram for Language:

Classes
struct	Base11
struct	Derived11

Functions
void	types_11 ()
void	unique_pounter ()
	unique_ptr More...
void	shared_pointer ()
	shared_ptr More...
void	weak_pointer ()
	weak_ptr More...
void	dynamic_memory_11 ()
char	func_type (const int &x)
char	func_type (int &x)
char	func_type (int &&x)
template<class T >
char	func_type_template (T &&x)
	Forwarding reference More...
void	references_11 ()
void	init_11 ()
auto	trailing_return_type (int a) -> int
void	copy_elision_demo ()
	copy_elision More...
void	func_11 ()
constexpr int	constexpr_factorial (int n)
	https://en.cppreference.com/w/cpp/language/constexpr More...
template<typename T >
constexpr T	adder (T v)
	https://en.cppreference.com/w/cpp/language/parameter_pack More...
template<typename T , typename... Args>
constexpr T	adder (T first, Args... args)

Variables
auto	auto_int = 1
	https://en.cppreference.com/w/cpp/language/auto More...

Detailed Description

Function Documentation

adder() [1/2]

template<typename T , typename... Args>

constexpr T adder ( T  first, Args...  args  )

constexpr

Definition at line 323 of file 11.cpp.

                                         {
  return first + adder(args...);
}

Here is the call graph for this function:

adder() [2/2]

template<typename T >

constexpr T adder ( T  v )

constexpr

https://en.cppreference.com/w/cpp/language/parameter_pack

Definition at line 318 of file 11.cpp.

                       {
  return v;
}

Here is the caller graph for this function:

constexpr_factorial()

constexpr int constexpr_factorial ( int  n )

constexpr

https://en.cppreference.com/w/cpp/language/constexpr

Definition at line 310 of file 11.cpp.

{
    return n <= 1 ? 1 : (n * constexpr_factorial(n - 1));
}

Here is the call graph for this function:

Here is the caller graph for this function:

copy_elision_demo()

void copy_elision_demo

(

)

copy_elision

Definition at line 275 of file 11.cpp.

{
    struct Obj2 { Obj2* orig = this; int ballast[4]; };
    auto&& o2 = [](){ return Obj2();}();
    assert(&o2 == o2.orig);
}

dynamic_memory_11()

void dynamic_memory_11

(

)

new,

delete

Definition at line 126 of file 11.cpp.

{
    auto a = new int[3] {1, 2, 3};
    assert(a[2] == 3);
    delete[] a;
 
    auto as = new string[3] {"1", "2", "3"};
    assert(as[2] == "3");
    delete[] as; // calls destructors for all members
 
    unique_pounter();
 
    shared_pointer();
 
    weak_pointer();
}

Here is the call graph for this function:

Here is the caller graph for this function:

func_11()

void func_11

(

)

Definition at line 282 of file 11.cpp.

{
    class functor {
        int y = 1;
        public:
        int operator()(int a) const {
            return a + y;
        }
    };
    functor ft;
    assert(ft(1) == 2);
 
    // https://en.cppreference.com/w/cpp/utility/functional/function
    function<int(int)> ft2 = ft;
    assert(ft(2) == 3);
    return;
 
    // https://en.cppreference.com/w/cpp/utility/functional/bind
    auto binded = bind(ft2, 3);
    assert(binded() == 5);
 
    copy_elision_demo();
}

Here is the caller graph for this function:

func_type() [1/3]

char func_type

(

const int &

x

)

func_type - overloaded functions remove_reference

Definition at line 146 of file 11.cpp.

{
    assert(is_const<typename remove_reference<decltype(x)>::type>::value);
    assert(is_lvalue_reference<decltype(x)>::value);
    return 'C';
}

Here is the caller graph for this function:

func_type() [2/3]

char func_type

(

int &&

x

)

Definition at line 159 of file 11.cpp.

{
    assert(is_rvalue_reference<decltype(x)>::value);
    return 'R';
}

func_type() [3/3]

char func_type

(

int &

x

)

Definition at line 153 of file 11.cpp.

{
    assert(is_lvalue_reference<decltype(x)>::value);
    return 'L';
}

func_type_template()

template<class T >

char func_type_template

(

T &&

x

)

Forwarding reference

Definition at line 168 of file 11.cpp.

{
    // x is not R-value here
    assert(func_type(x) != 'R');
 
    // x can be forwarded as R or L value
    // https://en.cppreference.com/w/cpp/utility/forward
    return func_type(forward<T>(x)); // like func_type((T)(x));
}

Here is the call graph for this function:

Here is the caller graph for this function:

init_11()

void init_11

(

)

direct_initialization

zero_initialization

list_initialization

initializer_list

Member_initialization

aggregate_initialization

reference_initialization

Definition at line 231 of file 11.cpp.

{
    struct C { int a, b, c; };
    auto o2 = C {1, 2, 3};
    C o3 {1, 2, 3};
    (void) o3;
 
    auto uses_il = [](initializer_list<int> il) {
        assert(*il.begin() == 3);
        assert(il.size() == 4);
    };
    uses_il({3, 2, 1, 0});
 
    auto z1 = C();
    C z2 = {};
    auto z3 = C {};
 
    assert(!z1.a);
    assert(!z2.a);
    assert(!z3.a);
    array<int, 3> a {1, 2};
}

Here is the caller graph for this function:

references_11()

void references_11

(

)

References

is_reference, ref, reference_wrapper

Definition at line 186 of file 11.cpp.

{
    // https://en.cppreference.com/w/cpp/language/reference
    assert(is_reference<int&>::value);
 
    // L-value:
    assert(is_lvalue_reference<int&>::value);
 
    // R-value
    assert(is_rvalue_reference<int&&>::value);
 
    const int c = 1;
    int i = 2;
 
    assert(func_type(3) == 'R');
    assert(func_type(c) == 'C');
    assert(func_type(move(i)) == 'R');
 
    assert(func_type_template(c) == 'C');
    assert(func_type_template(i) == 'L');
    assert(func_type_template(3) == 'R');
    reference_wrapper<int> rw = i;
    rw.get() = 3;
    assert(i == 3);
    auto cr = cref(i);
    assert(cr == 3);
}

Here is the call graph for this function:

Here is the caller graph for this function:

shared_pointer()

void shared_pointer

(

)

shared_ptr

Definition at line 86 of file 11.cpp.

{
    shared_ptr<int> s1;
    assert(!s1);
    assert(!s1.use_count());
 
    auto s2 = make_shared<int>(1);
    assert(s2.use_count() == 1);
 
    s1 = s2;
    assert(s1.use_count() == 2);
 
    *s1 = 2;
    assert(*s1 == *s1.get());
    assert(*s2 == 2);
 
    s2 = nullptr; // like s2.reset();
    assert(s1.use_count() == 1);
    assert(!s2.use_count());
}

Here is the caller graph for this function:

trailing_return_type()

auto trailing_return_type

(

int

a

)

-> int

Definition at line 268 of file 11.cpp.

{
    return a;
}

Here is the caller graph for this function:

types_11()

void types_11

(

)

Definition at line 32 of file 11.cpp.

{
    static_assert(__cpp_decltype, "");
 
    int a;
    // https://en.cppreference.com/w/cpp/header/type_traits
    decltype(a) b; // https://en.cppreference.com/w/cpp/language/decltype
 
    assert((is_same<decltype(a), decltype(b)>::value));
    assert((!is_same<decltype(a), unsigned>::value));
    assert((is_same<int, int32_t>::value));
    assert((is_same<signed, int32_t>::value));
 
    assert(is_integral<int>::value);
    assert(is_integral<bool>::value);
    assert(!is_integral<float>::value);
    assert(is_pointer<int*>::value);
    assert(sizeof (long long) >= 8);
}

Here is the caller graph for this function:

unique_pounter()

void unique_pounter

(

)

unique_ptr

Definition at line 54 of file 11.cpp.

{
    int d = 0;
    unique_ptr<int> u1;
    assert(!u1);
    u1.reset(&d);
    assert(u1);
    *u1 = 1;
    assert(d == 1);
 
    unique_ptr<int> u2;
    // u2 = u1; - prohibited
 
    int * p1 = u1.get();
    u2 = move(u1); // [move](https://en.cppreference.com/w/cpp/utility/move)
    assert(u2.get() == p1);
    assert(u2);
    assert(!u1);
    assert(u2.get() == &d);
    // must release because d is local
    u2.release();
    u2.reset(new int(10));
    assert(*u2 == 10);
 
    u2.reset(); // deletes int(10)
    assert(u2 == nullptr); // [nullptr](https://en.cppreference.com/w/cpp/language/nullptr)
 
    assert(!u2);
}

Here is the caller graph for this function:

weak_pointer()

void weak_pointer

(

)

weak_ptr

Definition at line 109 of file 11.cpp.

{
    std::weak_ptr<int> wp;
 
    assert(!wp.lock());
    assert(!wp.use_count());
    auto sp = std::make_shared<int>(1);
    wp = sp;
    assert(*wp.lock() == 1);
}

Here is the caller graph for this function:

Variable Documentation

auto_int

auto auto_int = 1

https://en.cppreference.com/w/cpp/language/auto

Trailing return type

https://en.cppreference.com/w/cpp/language/function

https://www.ibm.com/support/knowledgecenter/en/ssw_ibm_i_73/rzarg/trailing_return.htm

Definition at line 265 of file 11.cpp.