When I started my studies in programming languages, I came across a series of terms that are foreign to my everyday philosophy, so that the acronym "WTF" does not leave my head. It was a new cycle of experiences that had begun, bordering on other dreams, realizing in me the need to live it with the same intensity that I felt all at first sight. I realized with this, an absolute desire to familiarize myself with the "keywords" referring to the C ++ language, and decided today, to share this first experience with you.

C++ language keywords:

keyword(palavra-chave) Description(Descrição)

and ------------------------------------- alternative to && operator

and_eq ----------------------------------- alternative to &= operator

asm ---------------------------------------- insert an assembly instruction

auto --------------------------------------- Declare a local variable, or we can let the compiler to deduce the type of the variable from the inicialization)

bitand -------------------------------------- alternative to bitwise & operator

bitor ----------------------------------------- alternative to | operator

bool ------------------------------------------ declare a boolean variable

break ----------------------------------------- break out of a loop

case ------------------------------------------- a block of code in a switch statement

catch ------------------------------------------ handles exeptions from trow

char ------------------------------------------- declare a character variable

class ------------------------------------------- declare a class

compl ----------------------------------------- alternative to ~ operator

const ------------------------------------------ declare immutable data or functions that do not change data

const_cast ----------------------------------- cast from const variables

continue -------------------------------------- bypass iterations of a loop

default ---------------------------------------- default handler in a case statement

#define ---------------------------------------- all header files should have #define guards to prevent multiple inclusion

delete ------------------------------------------ make dinamic memory available

do ----------------------------------------------- looping construct

double ------------------------------------------ declare a double precision floating-point variable

dynamic_cast ---------------------------------- perform runtime casts

else ----------------------------------------------- alternate case for an if statement

enum --------------------------------------------- create enumeration types

exit()----------------------------------------------- ending a process

explicit ------------------------------------------- only use constructors when they exactly match

export--------------------------------------------- Allows template definitions to be separated from theis declarations

extern---------------------------------------------declares a variable or function and specifies that it has external linkage

Extern “C”---------------------------------------- enables C function call from C++ by forcing C-linkage

false----------------------------------------------- a constant representing the boolean value

float------------------------------------------------declare a float-point variable

friend----------------------------------------------- grant non-member function access to private data

goto------------------------------------------------jump to a diferent part of the program

if----------------------------------------------------execute code based on the result of a test

inline----------------------------------------------optimize calls to short functions

int--------------------------------------------------declare a integer variable

long------------------------------------------------declare a long integer variable

mutable-------------------------------------------override a const variable

namespace---------------------------------------partition the global namespace by defining a scope

new------------------------------------------------Allocate dynamic memory of a new variable

not------------------------------------------------- alternative to ! Operator

not_eq --------------------------------------------alternative to != operator

operator-------------------------------------------creat overloaded operator functions

or--------------------------------------------------- alternative to || operator

or_eq----------------------------------------------- alternative to |= operator

private----------------------------------------------declare private members of a class

protected-------------------------------------------declare protected members of a class

public-----------------------------------------------declare public members of a class

register---------------------------------------------request that a variable be optimized for speed

reinterpret_cast----------------------------------- change the type of a variable

short------------------------------------------------- declare a short integer variable

signed-----------------------------------------------modify a variable type declarations

sizeof------------------------------------------------return the size of a variable or type

static------------------------------------------------create a permanent storage for a variable

static_cast-----------------------------------------perform a nonpolymorphic cast

stuct-------------------------------------------------define a new structure

switch----------------------------------------------- execute code based on diferent possible values for a variable

template-------------------------------------------- create generic functions

this-------------------------------------------------- a pointer to the current object

throw------------------------------------------------throws an exeption

true--------------------------------------------------A constant representing the boolean true value

try----------------------------------------------------execute code that can throw an exception

typedef----------------------------------------------create a new type name from a existing type

typeid-----------------------------------------------describes an object

typename-------------------------------------------declare a class or undefined type

union------------------------------------------------a structure that assigns multiple variables to the same memory location

unsigned-------------------------------------------declare an unsigned integer variable

using------------------------------------------------import complete or partial namespaces into the current scope

virtual-----------------------------------------------create an function that can be overriden by a derived class

void-------------------------------------------------declare functions or data with no associaded data type

volatile---------------------------------------------warn the compiler about variables that can be modified unexpectedly

wchar_t--------------------------------------------declare a wide-character variable

while-----------------------------------------------looping construct

xor-------------------------------------------------alternative to ^ operator

xor_eq--------------------------------------------alternative to ^= operator