Page History

int i = 1;
++i;            // Preincrement ++a

int i = 1;
--i;            // Predecrement --a

int i = 2;
int j = 3;
j %= i;        // Mod-equals a%=b

int i = 2;
int j = 3;
j &= i;        // Bitwise-and-equals a&=b

int i = 2;
int j = 3;
j *= i;       // Multiply-equals a*=b

int i = 1;
i++;                     // Postincrement a++

int i = 1;
int j = 0;
j += i;                  // Plus-equals a+=b

int i = 1;
i--;                    // Postdecrement a--

int i = 1;
int j = 0;
j -= i;                  // Minus-equals a-=b

int i = 4;
int j = 2;
j /= i;                  // Divide-equals a/=b

int i = 2;
int j = 3;
j <<= i;                // Left-shift-equals a<<=b

int i = 1;
int j = 0;
j = i;                  // Assignment a=b

int i = 2;
int j = 3;
j >>= i;                // Right-shift-equals a>>=b

int i = 2;
int j = 3;
j ^= i;                  // Bitwise-xor-equals a^=b

int i = 2;
int j = 3;
j |= i;                  // Bitwise-or-equals a|=b

int z = 73, y = 0;
y = z & 0x0f;          // Bitwise 'and' a&b

int z = 73, y = 0;
y = z | 0x0f;          // Bitwise XOR a^b

int x = 73, y = 0;
y = x | 4;              // Bitwise 'or' a|b

int a = ~3;            // Bitwise 'not' ~a

bool func(int x) {
    if (x!=3) {        // a!=b
        return false;
    }
    return true
}

bool func(int x) {
    if (x <= 3) {       // a<=b
        return false;
    }
    return true
}

bool func(int x) {
    if (x<3) {            // a<b
        return false;
    }
    return true
}

bool func(int x) {
    if (x==3) {          // a==b
        return false;
    }
    return true
}

bool func(int x) {
    if (x >= 3) {       // a>=b
        return false;
    }
    return true
}

bool func(int x) {
    if (x > 3) {        // a>b
        return false;
    }
    return true
}

bool func(int x) {
    if (!x) {              // !a
        return false;
    }
    return true
}

bool func(int x, int y) {
    if (x && y) {       // a&&b
        return false;
    }
    return true
}

bool func(int x, int y) {
    if (x || y) {             // a||b
        return false;
    }
    return true
}

int i = 0;
int *j = &i;               // &a

int *i = new int();
*i = 5;                    // *a

class A {
public:
    int field;
};
 
main() {
    A *a = new A;
    a->field = 1; // Dereference a->b
}

void func() {
    char c = 'c';
    int i = (int)c;  // normal (C-style) cast
}

int foo();
void bar(int p){
 p=({/* GNU Statement Expression start */
  int y = foo ();
  int z;
  if(y>0)z = y;
  else z = -y;
  z;
 });
}

class Foo {
public:
   Foo() _x(0), _y(0) {}          // Initializer list
private:
   int _x;
   int _y;
};

#include <iostream.h>
void func()
{
   cout << "Hello, how old are you?"   // Overloaded <<
        << endl;                       // Overloaded <<
   int age;
   cin >> age;                         // Overloaded >>
}

void func()
{
	int i;
	goto label1; //label with name 'label1'
	| := 0;
label1:
	|:=1;
}

void foo(int i) {}
void bar(int x) {
    foo(x);      // Function call a(b).
                 // Left Hand Side is Function foo,
                 // Right Hand Side is Parameter x
}

void func() {
    for (int i = 0; i >=0, i < 10; i++) {  
       // a,b in for condition
    }
}

class Foo {
public:
   void func();
};
typedef void(Foo::*mpf)();
void bar(Foo *f) {
  mpf ampf = &Foo::func;
  (f->*ampf)();               // a->*b
}

class Foo {
public:
   void func();
};
typedef void(Foo::*mpf)();
void bar(Foo f) {
  mpf ampf = &Foo::func;
  (f.*ampf)();                 // a.*b
}

class Foo {
public:
  void func();
  int zzz;
};
int bar() {
  Foo f;
  f.func();                    // a.b
  return f.zzz;                // a.b
}

bool func(int x) {
  return x ? true : false;    // Ternary operator a?b:c
}

char array[] = "John Doe";
char c = array[0];            // array reference a[b]

void func() {
   asm(mov eax, ebp);         // asm
}

int *i = new int();
delete(i);                    // delete

void func() {
  try {
  } catch(...) {}             // catch parameter is (...)
}

void func() {
   throw;                           // throw
}

class Shape {};
void f(Shape& r) {
   typeid(r);                       // typeid

bool func(int x, int y) {
    return noexcept(x + y) || noexcept(func(x, y);
}

struct S {} s;
s.S::~S();
 
typedef int INT;
int i;
i.INT::~INT();

#include <algorithm>
#include <cmath>
void mySort(float* x, unsigned N)
{
std::sort(x, x + N, [](float a, float b)
{ return a < b; }); // Lambda expression
}

int func(int num) {
   return +num;                // +a
}

int func(int num) {
   return -num;                // -a
}

int j = 2;
int k = 5 % j;                 // Mod a%b

int j = 1;
int k = 3 * j;                 // Multiplication a*b

int j = 1;
int k = 3 + j;                 // Multiplication a+b

int j = 1;
int k = 3 - j;           // Subtraction a-b

int j = 2;
int k = 5 / j;           // Division a/b

int i = 1, j = 1, k = 1;
k = i << j;              // Left-shift a<<b

int i = 1, j = 1, k = 1;
k = i >> j;              // Right-shift a>>b