C/C++ tricks

C/C++ tricks
David Barina
April 13, 2018
David Barina C/C++ tricks April 13, 2018 1 / 59

Duﬀ’s device
switch (count % 8) {
case 0: do { *to = *from ++;
case 7: *to = *from ++;
} while (( count -= 8) > 0);
}

[] operator
const char *a = "0123456789 abcdef";
int i = ...;
char digit = a[i];
char digit = *(a+i);

[] operator
const char *a = "0123456789 abcdef";
int i = ...;
char digit = a[i];
char digit = *(a+i);
char digit = i[a];

Swap algorithm
void swap(int *a, int *b)
{
int temp = *a;
*a = *b;
*b = temp;
}
void swap(int *a, int *b)
{
*a ^= *b;
*b ^= *a;
*a ^= *b;
}

--> operator
int x = 10;
while( x --> 0 )
while( 0 <-- x )
while( 0 <---- x )

Catching exceptions in initializer lists
struct A {
A() : b() { ... }
B b;
};
A() : b() {
try {
...
} catch (...) {
...
}
}

Catching exceptions in initializer lists
struct A {
A() : b() { ... }
B b;
};
A() try : b() {
...
} catch (...) {
...
}

Namespace aliases
namespace foo {
namespace bar {
namespace baz {
int qux = 42;
}
}
}
namespace fbz = foo::bar::baz;
std:: cout << fbz::qux << ’n’;

Namespace aliases
#if THREADS_ARE_SUPPORTED_ON_THE_PLATFORM
namespace lib = project ::lib:: impl_with_threads ;
#else
namespace lib = project ::lib:: impl_wout_threads ;
#endif

Storage class speciﬁers
typedef int type;
int typedef type;
// static , extern

Integer overﬂow
for(char c = 100; c > 0; c++)
printf("%in", (int)c);

Integer promotion
char c = ’X’;
cout << c;

Integer promotion
char c = ’X’;
cout << c;
cout << +c;

Polyglot
$CC -std=c90 -pedantic -Wall -Wextra prog.c && ./a.out
I am compiled with C90
I am compiled with C99
I am compiled with C11 or newer
$CXX -std=c++98 -pedantic -Wall -Wextra prog.c && ./a.out
I am compiled with C++03 or older
I am compiled with C++03 or older
I am compiled with C++11 or newer

Polyglot
if( sizeof(’a’) == sizeof(char) )
{
// compiled with C++
}
else
{
// compiled with C
}

Polyglot
#define R(U) sizeof(U"a"[0])
if( R("") == 4 )
{
// C++11 or newer
}
else
{
// C++03 or older
}

Polyglot
if( 2 // **/2
== 2 )
{
if( R("") == 4 )
{
// C11 or newer
}
else
{
// C99
}
}
else
{
// C90
}

Named loops

Named loops
outer: for( ... )
{
inner: for( ... )
{
...
goto outer;
}
}

Named loops
for( ... )
{
for( ... )
{
...
goto after;
}
}
after :;

Named loops
if( 0 )
after :;
else
for( ... )
{
for( ... )
{
...
goto after;
}
}

Named loops
[](){
for( ... )
{
for( ... )
{
...
return;
}
}
}();

Copy-and-swap
class dumb_array
{
public:
dumb_array(std:: size_t size = 0);
dumb_array(const dumb_array& other );
~dumb_array ();
private:
std:: size_t mSize;
int* mArray;
};

Copy-and-swap
dumb_array& operator =( const dumb_array& other)
{
if (this != &other) // (1)
{
delete [] mArray; // (2)
mArray = nullptr; // (2)
mSize = other.mSize; // (3)
mArray = mSize ? new int[mSize]
: nullptr; // (3)
std:: copy(other.mArray ,
other.mArray + mSize ,
mArray ); // (3)
}
return *this;
}

Copy-and-swap
friend void swap(dumb_array& first ,
dumb_array& second) // nothrow
{
using std:: swap;
swap(first.mSize , second.mSize );
swap(first.mArray , second.mArray );
}
dumb_array& operator =( dumb_array other) // (1)
{
swap (*this , other ); // (2)
return *this;
}

Member call on null pointer
class A {
int x;
public:
void foo() {
std:: cout << "foo" << std:: endl;
x = 0;
}
};
int main () {
A *a = 0;
a->foo ();
}

class A {
int x;
public:
void foo() {
std:: cout << "foo" << std:: endl;
x = 0;
}
};
int main () {
A *a = 0;
a->foo ();
}
foo
Neopr´avnˇen´y pˇr´ıstup do pamˇeti (SIGSEGV)

class A {
int x;
public:
void bar() {
std:: cout << "bar" << std:: endl;
}
};
int main () {
A *a = 0;
a->bar ();
}

class A {
int x;
public:
void bar() {
std:: cout << "bar" << std:: endl;
}
};
int main () {
A *a = 0;
a->bar ();
}
bar

Integer overﬂow
int a = /* something */;
int b = /* something */;
a += b;
if( a < 0 ) {
/* ... */
}

Integer overﬂow
a += b; /* UB */
if( a < 0 ) { /* unreliable test */
/* ... */
}

Integer overﬂow
if( /* test */ ) {
/* ... */
}
a += b;

Integer overﬂow
C
#include <limits.h>
CHAR_MIN , SHRT_MIN , INT_MIN , LONG_MIN
CHAR_MAX , SHRT_MAX , INT_MAX , LONG_MAX
C++
#include <limits >
std:: numeric_limits <T>:: min()
std:: numeric_limits <T>:: max()

Integer overﬂow
addition ‘a + b‘
if( (b > 0) && (a > INT_MAX - b) )
/* would overflow */;
if( (b < 0) && (a < INT_MIN - b) )

Integer overﬂow
subtraction ‘a - b‘
if( (b < 0) && (a > INT_MAX + b) )
if( (b > 0) && (a < INT_MIN + b) )

Integer overﬂow
multiplication ‘a * b‘
if( (b != 0) && (a > INT_MAX / b) )
if( (b != 0) && (a < INT_MIN / b) )

Integer overﬂow
multiplication ‘a * b‘
if( (b != 0) && (a > INT_MAX / b) )
if( (b != 0) && (a < INT_MIN / b) )
if( (a == -1) && (b == INT_MIN) )
if( (b == -1) && (a == INT_MIN) )

Integer overﬂow
division ‘a / b‘
if( (b == -1) && (a == INT_MIN) )

Implicit type conversion
int a = 5;
int b = a; /* <--- */

int a = 5;
int b = a; /* nothing interesting */

char a = 5;
int b = a; /* <--- */

char a = 5;
int b = a; /* implicit type conversion */

int a = 5;
char b = a; /* implicit type conversion */

int a = 300;
char b = a; /* alter a value */

int i = -1;
unsigned int u = i; /* change the sign */

-Wconversion
warning: conversion to ‘int’ from ‘long int’
may alter its value
warning: conversion to ‘unsigned char’ from ‘int’
may alter its value
-Wsign-conversion
warning: negative integer implicitly converted
to unsigned type
warning: conversion to ‘unsigned int’ from ‘int’
may change the sign of the result

Explicit type conversion (cast notation)
int a = 5;
char b = (char)a; /* no warning */
std:: cout << +b << std:: endl; // 5

Explicit type conversion (conversion operator)
int a = 5;
char b = static_cast <char >(a);
std:: cout << +b << std:: endl; // 5

int a = 5;
double *b = (double *)&a; /* no warning */
std:: cout << *b << std:: endl; // 2.47033e -323

int a = 5;
double *b = static_cast <double *>&a;
error: invalid static_cast from type ‘int*’
to type ‘double*’

int a = 5;
double *b = reinterpret_cast <double *>(&a);
std:: cout << *b << std:: endl; // 2.47033e -323

Explicit type conversion
( new_type ) expression
const_cast<new_type>(expression)
static_cast<new_type>(expression)
static_cast followed by const_cast
reinterpret_cast<new_type>(expression)
reinterpret_cast followed by const_cast

-Wold-style-cast
warning: use of old-style cast

Initializer lists
class A {
int i;
public:
A() { i = 0; } // default
A(int i_) { i = i_; } // init
A& operator =(int i_) { i = i_; } // init
};
class B {
A a;
public:
B() { a = 3; } // default , init
};

Initializer lists
class A {
int i;
public:
A() { i = 0; } // default
A(int i_) { i = i_; } // init
A& operator =(int i_) { i = i_; } // init
};
class B {
A a;
public:
B() : a(3) {} // init
};

const member
class A {
public:
const int i;
A(int i_) { i = i_; }
};
error: assignment of read-only member ‘A::i’

const member
class A {
public:
const int i;
A(int i_) : i(i_) {}
};

const member
class A {
public:
const int i;
A(int i_) : i(i_) {}
A& operator =( const A& a) {
i = a.i;
return *this;
}
};
error: assignment of read-only member ‘A::i’

const member
class A {
public:
const int i;
A(int i_) : i(i_) {}
return *new(this) A(a);
}
};
A a(3);
a = A(4);
std:: cout << a.i << std:: endl; /* UB */

const member
class A {
public:
const int i;
A(int i_) : i(i_) {}
}
};
A a(3);
std:: cout << (a = A(4)).i << std:: endl;

const member (C++17)
class A {
public:
const int i;
A(int i_) : i(i_) {}
}
};
A a(3);
a = A(4);
std:: cout << std:: launder (&a)->i << std:: endl;

C/C++ tricks

More Related Content

Similar to C/C++ tricks

More from David Bařina

Recently uploaded

C/C++ tricks