#include <iostream> // Entrada e saída de dados using namespace std; // Declarando espaço de nome std padrão int main(int argc, char *argv[]) { int var = 10; int* pvar; // Ponteiro // Sempre inicializar um ponteiro antes de utilizá-lo pvar = &var; // &var é o endereço da variável var cout << *pvar << endl;//acessa o conteúdo da variável através do *pvar *pvar = 20; // muda o valor da variável através do ponteiro cout << var << endl; return 0; }
| 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 |
