Hoja de trucos de C++ para referencias rápidas (Descargar PDF)

C++ es un lenguaje de propósito general y una extensión del lenguaje C. Como uno de los lenguajes de programación más demandados en el mercado actual, C++ es una opción de estudio popular para los aspirantes a desarrolladores. Los programadores toman cursos y experimentan con proyectos de C++ para mejorar sus conocimientos.

Pero, ¿alguna vez desea una referencia rápida de C++ mientras trabaja? ¿Qué pasaría si pudiera completar el trabajo de C++ de manera más eficiente? Esta hoja de trucos de C++ es una excelente referencia para ayudarlo a trabajar sin problemas.

Hemos seleccionado una increíble hoja de trucos de sintaxis de C++ o una hoja de trucos de comandos de C++ que le ayudarán a mejorar o pulir sus habilidades.

Esta hoja de trucos de programación en C++ también es un buen recurso para la preparación de entrevistas. ¿Listo para abordar proyectos de C++ de forma rápida? ¡Empecemos!

Descargar el PDF de la hoja de trucos de C++

Hoja de referencia de C++

Sintaxis 

Comencemos nuestra hoja de referencia de C++ con la sintaxis.

#include <iostream>
usingnamespacestd;

intmain() {
cout << "Hello World!";
return0;
}

Mientras escribe código en C++, siempre asegúrese de terminar cada línea con un punto y coma para especificar el final de la línea. También debe agregar el corchete de cierre para finalizar la función principal; de lo contrario, obtendrá errores al compilar el código.

• Línea 1: ‘#include ’ especifica la biblioteca de archivos de cabecera , que lo ayuda a manejar objetos de entrada y salida como "cout". Los archivos de encabezado se utilizan para agregar funciones específicas a los programas de C++.
• Línea 2: ‘using namespace std’ le permite usar nombres para objetos y variables de la biblioteca estándar.
• Línea 3: Linea en blanco. C++ ignora los espacios presentes en el código.
• Línea 4: ‘int main()’, que es una función. Se ejecutará cualquier código entre llaves {}.
• Línea 5: cout es un objeto que se usa junto con el operador de inserción (<<) para imprimir el texto de salida.
• Línea 6: return 0 se usa para finalizar la función principal.

Comentarios 

En C++, el compilador ignora el texto seguido de los comentarios. C++ admite dos tipos diferentes de comentarios:

//: especifica el comentario de una sola línea.

/* ….*/ :especifica el comentario de varias líneas.

Tipos de datos 

Los tipos de datos especifican el tipo de la variable de datos. El compilador asigna la memoria en función de los tipos de datos. Los siguientes son los tipos de datos de C++:

• Tipos de datos integrados o primitivos: Tipos de datos predefinidos que se pueden usar directamente, incluidos enteros, caracteres, booleanos, puntos flotantes, puntos flotantes dobles, sin valor o vacíos y caracteres anchos.
• Tipos de datos derivados: Derivado de tipos de datos primitivos:función, matriz, puntero y referencia.
• Tipos de datos definidos por el usuario: Definido por los usuarios:clase, estructura, unión, enumeración y Typedef.

Variables 

Las variables almacenan los valores de los datos. C++ admite varios tipos de variables, como int, double, string, char y float.

Por ejemplo:

int num = 12; // Integer
string name = "Unity Buddy"; // String(text)
char ch = 'U'; //character
float fl = 5.99; // Floating point number

Puede usar letras, números y guiones bajos para un nombre de variable. Sin embargo, las variables no pueden comenzar con números o el carácter de subrayado '_'. En cambio, comienzan con letras seguidas de números o el carácter de subrayado '_'. Además, no puede utilizar una palabra clave para el nombre de la variable.

Alcance de Variables

En C++, puede declarar sus variables dentro de tres partes del programa, también conocido como el alcance de las variables:

1. Variables locales

Estas variables se declaran dentro de una función o bloque de código. Su alcance solo se limita a esa función o bloque y no se puede acceder a él mediante ninguna otra declaración fuera de ese bloque.

Por ejemplo:

#include <iostream>
usingnamespacestd;

intmain () {
// Local variable:
int a, b;
int c;

// initialization
a = 10;
b = 20;
c = a + b;

cout << c;

return0;
}

2. Variables globales

Las variables globales son accesibles para cualquier función, método o bloque del programa. Por lo general, se define fuera de todas las funciones. El valor de la variable global es el mismo en todo el programa.

Por ejemplo:

#include <iostream>
usingnamespacestd;

// Global variable:
int g;

intmain () {
// Local variable:
int a, b;

// initialization
a = 10;
b = 20;
g = a + b;

cout << g;

return0;
}

Modificadores de tipo de datos 

Los modificadores de tipo de datos se utilizan para modificar la longitud máxima de datos de un tipo de datos. La siguiente tabla lo ayudará a comprender el tamaño y el rango de los tipos de datos integrados cuando se combinan con modificadores. Hay cuatro tipos diferentes de modificadores disponibles en C++, a saber, firmados, sin firmar, cortos y largos.

Literales

Los literales en C++ son datos que puede usar para representar los valores fijos. Puede usarlos directamente dentro del código.

Por ejemplo, 1, 2.5, “s”, etc.

Hay diferentes tipos de literales disponibles en C++, como se explica a continuación:

1. Literal entero

Un literal entero es numérico y no tiene ninguna parte fraccionaria o exponencial.

Por ejemplo: 

Decimales (base 10):0, -9, 22, etc.

Octal (base 8):021, 077, 033, etc.

Hexadecimal (base 16):0x7f, 0x2a, 0x521, etc.

2. Literales de punto flotante

Estos son literales numéricos que tienen una parte fraccionaria o una parte exponencial.

Por ejemplo:(-2.0, 0.8589, -0.26E -5).

3. Caracteres literales

Estos son caracteres individuales encerrados entre comillas simples.

Por ejemplo:'a', 'F', '2', etc.

4. Secuencias de escape

Puede usar secuencias de escape en C++ para caracteres no tipificables que tienen un significado especial en C++.

Por ejemplo:

5. Literal de cadena

Esta es una secuencia de caracteres entre comillas dobles.

Por ejemplo:

Constantes 

Para crear una variable para la que no desea cambiar los valores, puede utilizar la palabra clave "const".

Por ejemplo:

constint LIGHT_SPEED = 2997928;
LIGHT_SPEED = 2500// cannot change the value

Funciones matemáticas

C++ proporciona varias funciones que le permiten realizar tareas matemáticas. La siguiente tabla destaca todas las funciones matemáticas básicas disponibles en C++:Funciones matemáticas

Entradas de usuario

C++ admite "cout" y "cin" para mostrar resultados y recibir entradas de los usuarios, respectivamente. cout usa el operador de iteración (<<), y cin usa (>>).

Por ejemplo:

int x; // declaring a variable
cout << "Type a number: "; // Type any number and hit enter
cin >> x; // Get user input from the keyboard
cout << "Your number is: " << x; // Display the value

Cadenas 

Una cadena es una colección o secuencia de caracteres entre comillas dobles.

Por ejemplo:

string str= "Hello";

Para usar una cadena dentro de su código, debe incluir la biblioteca de cadenas usando esta línea de código: 

#include <string>

C++ le permitirá realizar varias funciones para manipular cadenas. La siguiente tabla describe los nombres de las funciones y sus descripciones:

Operadores 

C++ admite diferentes tipos de operadores para agregar lógica a su código y realizar operaciones en variables y sus respectivos valores. Estos son los tipos de operadores de C++: 

1. Operadores Aritméticos

Puede realizar operaciones matemáticas comunes con operadores aritméticos.

2. Operadores de asignación

Puede asignar valores a variables con operadores de asignación.

3. Operadores de comparación

Puede usar estos operadores para comparar dos valores y devolver un valor verdadero o falso. Devolverá verdadero si ambos valores coinciden y falso si no coinciden.

4. Operadores Lógicos

Estos operadores determinan la lógica entre variables.

Declaraciones para tomar decisiones

Las declaraciones de toma de decisiones en C++ deciden el flujo de ejecución del programa. Aquí, los programadores especifican más de una condición. Si una condición se cumple, se ejecutan las declaraciones en ese bloque. De lo contrario, se ejecutan las declaraciones de otros bloques en su lugar.

C++ tiene varias instrucciones para la toma de decisiones:

• Instrucción If
• si... otra declaración
• Declaración de cambio
• Declaración if anidada
• Declaración de cambio anidado
• Operador ternario

1. Declaración If

Este es el tipo más básico de declaración de toma de decisiones. Le indica al compilador que ejecute el bloque de código solo si la condición se cumple.

Sintaxis:

if (expression)
{ //code}

Ejemplo: 

#include <iostream>
usingnamespacestd;

intmain () {
int b = 10;
if( b < 20 ) {
cout << "b is less than 20;" << endl;
}
cout << "value of a is : " << b << endl;

return0;
}

2. Declaración If..Else

Esta es una extensión de la declaración 'si'. Le indica al compilador que ejecute el bloque 'si' solo si la condición especificada es verdadera. De lo contrario, ejecuta el bloque 'else'.

Sintaxis:

if (expression)
{//code}
else
{//code}

Ejemplo: 

#include <iostream>
usingnamespacestd;

intmain () {
int b = 10;
if( b < 20 ) {
cout << "b is less than 20;" << endl;
}
cout << "value of a is : " << b << endl;

return0;
}

3. Declaración de cambio

Cuando necesite ejecutar condiciones contra varios valores, puede usar declaraciones de cambio.

Sintaxis: 

switch(expression) {
case constant-expression :
statement(s);
break; //optional
case constant-expression :
statement(s);
break; //optional

default : //Optional
statement(s);
}

Ejemplo: 

#include <iostream>
usingnamespacestd;

intmain () {
// local variable declaration:
char grade = 'D';

switch(grade) {
case'A' :
cout << "Outstanding!" << endl;
break;
case'B' :
case'C' :
cout << "Well done" << endl;
break;
case'D' :
cout << "Pass" << endl;
break;
case'F' :
cout << "Try again" << endl;
break;
default :
cout << "Invalid grade" << endl;
}
cout << "Your grade is " << grade << endl;

return0;
}

4. Instrucción If anidada

Esta es una declaración "si" dentro de otra declaración "si". Puede usar este tipo de declaración cuando necesite basar una condición específica en el resultado de otra condición.

Sintaxis: 

if( boolean_expression 1) {
// Executes when the boolean expression 1 is true
if(boolean_expression 2) {
// Executes when the boolean expression 2 is true
}
}

Ejemplo: 

#include <iostream>
usingnamespacestd;

intmain () {
// local variable declaration:
int x = 100;
int y = 200;

if( x == 100 ) {
if( y == 200 ) {

cout << "Value of x is 100 and y is 200" << endl;
}
}
cout << "Exact value of x is : " << x << endl;
cout << "Exact value of y is : " << y << endl;

return0;
}

5. Declaración de cambio anidado

Puede incluir una declaración de cambio dentro de otra declaración de cambio.

Sintaxis: 

switch(ch1) {
case'A':
cout << "This A is part of outer switch";
switch(ch2) {
case'A':
cout << "This A is part of inner switch";
break;
case'B': // ...
}
break;
case'B': // ...
}

Ejemplo: 

#include <iostream>
usingnamespacestd;

intmain () {
int x = 100;
int y = 200;

switch(x) {
case100:
cout << "This is part of outer switch" << endl;
switch(y) {
case200:
cout << "This is part of inner switch" << endl;
}
}
cout << "Exact value of x is : " << x << endl;
cout << "Exact value of y is : " << y << endl;

return0;
}

6. Operador Ternario

Exp1? Exp2 :Exp3;

Primero, se evalúa la expresión Exp1. Si es cierto, se evalúa Exp2 y se convierte en el valor de la expresión "?" completa. Si Exp1 es falso, se evalúa Exp3 y su valor se convierte en el valor de la expresión.

Bucles 

Los bucles se utilizan para ejecutar un conjunto particular de comandos durante un número específico de tiempo según el resultado de la condición evaluada. C++ incluye los siguientes bucles

• Mientras bucle
• bucle Do-while
• bucle For
• Declaración de ruptura
• Continuar sentencia

1. Mientras Bucle

El ciclo continuará hasta que la condición especificada sea verdadera.

while (condition)
{code}

2. Bucle Do-While

Cuando la condición se vuelve falsa, el bucle do-while deja de ejecutarse. Sin embargo, la única diferencia entre el ciclo while y do-while es que el ciclo do-while prueba la condición después de ejecutando el bucle. Por lo tanto, el bucle se ejecuta al menos una vez.

do
{
Code
}
while (condition)

3. Bucle For

Puede usar el bucle for para ejecutar un bloque de código varias veces. Este ciclo ejecuta el bloque hasta que la condición especificada en él sea falsa.

for (int a=0; i< count; i++)
{
Code
}

4. Declaración de ruptura

Esto se usa para interrumpir el flujo del código para que el código restante no se ejecute. Esto te saca del bucle.

Por ejemplo: 

for (int i = 0; i < 10; i++) {
if (i == 4) {
break;
}
cout << i << "\n";
}

5. Continuar Declaración

Esta declaración interrumpirá el flujo y lo llevará a la evaluación de la condición. Más tarde, vuelve a iniciar la ejecución del código.

Por ejemplo:

for (int i = 0; i < 10; i++) {
if (i == 4) {
continue;
}
cout << i << "\n";
}

Matrices 

Las matrices son tipos de datos derivados que almacenan varios elementos de datos de tipos similares en ubicaciones de memoria contiguas.

Por ejemplo:

string vehicles [4]; //declaring array to store up to 4 variables.
string vehicles[4]= {"car", "scooter", "cycle", "bike"}; //initializing the array

1. Acceder a valores de matriz

Debe usar el número de índice para acceder a los elementos almacenados en una matriz.

string vehicles[4]= {"car", "scooter", "cycle", "bike"};
cout << vehicles [0];

2. Cambio de elementos de matriz

Puede cambiar los elementos almacenados en una matriz utilizando el número de índice.

string vehicles[4]= {"car", "scooter", "cycle", "bike"};
vehicles [0]= " "airplane";
cout << vehicles[0];

Funciones 

Una función es un grupo de instrucciones para llevar a cabo una tarea específica. La función común en todos los programas de C++ es la función main(). Incluso puede dividir su código complejo en múltiples funciones pequeñas y ejecutarlas por separado.

Para esto, debe declarar, definir y llamar a esa función. C++ tiene varias funciones integradas a las que puede llamar directamente desde cualquier programa.

Definiendo una Función

La siguiente es la sintaxis para definir una función en C++:

return_type function_name( parameter list ) {
body of the function
}

donde:

• return_type especifica el tipo de valor que devuelve esa función.
• nombre_función especifica el nombre de la función y debe ser único.
• lista de parámetros le permite pasar más de un valor a su función, junto con sus tipos de datos.
• cuerpo de la función Especifica el conjunto de instrucciones para realizar una tarea.

Por ejemplo:

intmax(int num1, int num2) { // declaring the function max
int result;

if (num1 > num2)
result = num1;
else
result = num2;

return result;
}

Llamar a una función

Debe llamar a una función donde la necesite en su programa.

Por ejemplo:

#include <iostream>
usingnamespacestd;

// function declaration
intmax(int num1, int num2);

intmain () {
int a = 100;
int b = 200;
int ret;

ret = max(a, b);
cout << "Max value is : " << ret << endl;

return0;
}

Argumentos de función

Puede pasar argumentos de tres formas:

• Llamada por valor: Pasa el valor real de un argumento al parámetro formal de la función. No realizará ningún cambio en el parámetro dentro de la función y no afectará al argumento.
• Llamada por puntero: Puede copiar una dirección de argumento en el parámetro formal. Aquí, la dirección accede al argumento real utilizado en la llamada. Esto significa que los cambios realizados en el parámetro afectan al argumento.
• Llamar por referencia: Puede copiar una referencia de argumento en el parámetro formal. La referencia accede al argumento real utilizado en la llamada. Esto significa que los cambios realizados en el parámetro afectan al argumento.

Clases de almacenamiento 

Las clases de almacenamiento definen la visibilidad de las variables y funciones. C++ admite varias clases de almacenamiento, como automático, registro, externo, estático y mutable.

1. Clase de almacenamiento automático

De forma predeterminada, C++ usa esta clase de almacenamiento para todas las variables.

Por ejemplo:

{
int var;
autoint var1;
}

Solo puede usar el "auto" dentro de las funciones para definir las variables locales.

2. Registrar clase de almacenamiento 

Esta clase de almacenamiento define las variables locales que se almacenarán dentro del registro en lugar de en la RAM. Es útil cuando desea acceder a la variable con frecuencia, como contadores. El tamaño de la variable tendrá un tamaño máximo igual al tamaño del registro.

Por ejemplo:

{
registerint miles;
}

3. Clase de almacenamiento estático

La clase de almacenamiento estático le dice al compilador que mantenga las variables locales en todo el programa sin necesidad de crearlas y destruirlas cuando entra y sale del alcance. Definir una variable como estática significa que mantendrá sus valores entre llamadas a funciones.

Las variables globales son estáticas, lo que significa que su alcance estará restringido a su archivo declarado. Si especifica un miembro de datos de clase como estático, crea solo una copia de ese miembro que compartirán todos los objetos de su clase.

Por ejemplo: 

#include <iostream>

// Function declaration
voidfunc1(void);

staticint count = 10; /* Global variable */

main() {
while(count--) {
func();
}

return0;
}

// Function definition
voidfunc1( void ) {
staticint i = 5; // local static variable
i++;
std::cout << "i is " << i ;
std::cout << " and count is " << count << std::endl;
}

Clase de almacenamiento externo

La clase de almacenamiento externo proporciona una referencia de una variable global y la hace visible para TODOS los archivos del programa. Cuando especifica una variable como 'externa', la variable no se puede inicializar porque apunta el nombre de la variable a una ubicación de almacenamiento que se ha definido previamente.

En el caso de varios archivos en los que defina una variable o función global, que también se utilizará en otros archivos, extern proporcionará una referencia en otro archivo de variable o función definida. Debe usar el modificador externo cuando tenga que compartir las mismas funciones o variables globales entre dos o más archivos.

Por ejemplo:

Programa 1

#include <iostream>
int count ;
externvoidwrite_extern();

main() {
count = 5;
write_extern();
}

Programa 2

#include <iostream>

externint count;

voidwrite_extern(void) {
std::cout << "Count is " << count << std::endl;
}

Clase de almacenamiento mutable

Puede usar esta clase de almacenamiento si desea que un miembro de objeto anule la función miembro. Es decir, un miembro mutable que puede ser modificado por una función de miembro const.

Estructura 

La estructura le permite definir los elementos de datos de los tipos de datos no similares. Para usar una estructura, debe definirla y acceder a sus miembros de estructura.

La siguiente es la sintaxis para crear una estructura:

struct [etiqueta de estructura] {
definición de miembro;
definición de miembro;
...
definición de miembro;
} [una o más variables de estructura];

Por ejemplo, queremos crear una estructura de libros que consta de título, autor, tema e id_libro, de la siguiente manera:

structBooks {
char title[50];
char author[50];
char subject[100];
int book_id;
} book;

Debe utilizar el operador de acceso a miembros (.) para acceder a los miembros de la estructura. Este es un período entre el nombre de la variable de estructura y el miembro de estructura al que deseamos acceder.

Acceso a los miembros de la estructura

#include <iostream>
#include <cstring>

usingnamespacestd;

structBooks {
char title[50];
char author[50];
char subject[100];
int book_id;
};

intmain() {
structBooksBook1; // Declare Book1 of type Book
structBooksBook2; // Declare Book2 of type Book

// book 1 specification
strcpy( Book1.title, "Learn C++ Programming");
strcpy( Book1.author, "Chand Miyan");
strcpy( Book1.subject, "C++ Programming");
Book1.book_id = 6495407;

// book 2 specification
strcpy( Book2.title, "Telecom Billing");
strcpy( Book2.author, "Yakit Singha");
strcpy( Book2.subject, "Telecom");
Book2.book_id = 6495700;

// Print Book1 info
cout << "Book 1 title : " << Book1.title <<endl;
cout << "Book 1 author : " << Book1.author <<endl;
cout << "Book 1 subject : " << Book1.subject <<endl;
cout << "Book 1 id : " << Book1.book_id <<endl;

// Print Book2 info
cout << "Book 2 title : " << Book2.title <<endl;
cout << "Book 2 author : " << Book2.author <<endl;
cout << "Book 2 subject : " << Book2.subject <<endl;
cout << "Book 2 id : " << Book2.book_id <<endl;

return0;
}

Referencias 

Cuando declaras una variable como referencia, actúa como una alternativa a la existente. Debe especificar la variable de referencia con "&", como se muestra a continuación:

string food = "Pizza";
string &meal = food; // reference to food

Puntero 

Un puntero en C++ es una variable que almacena la dirección de memoria de otra variable. Al igual que las variables regulares, los punteros también tienen tipos de datos. Usamos '*' para declarar punteros en C++.

Por ejemplo:

string food = "Pizza"; // string variable

cout << food; // Outputs the value of food (Pizza)
cout << &food; // Outputs the memory address of food (0x6dfed4)

Clases y Objetos 

C++ es un lenguaje de programación orientado a objetos con clases y objetos. La clase es un tipo de datos definido por el usuario que puede usar para vincular miembros de datos y funciones de miembros. Puede acceder a ellos creando una instancia de esa clase.

Creando una Clase

Aquí se explica cómo crear una clase en C++:

classMyClass { // The class
public: // Access specifier- accessible to everyone
int myNum; // Attribute (int variable)
string myString; // Attribute (string variable)
};

Creando un Objeto

Los objetos funcionan como una instancia de la clase, permitiéndole acceder a sus miembros, funciones y variables. Debe usar el operador de punto (.), como se muestra a continuación:

classMyClass {
public:
int myNum;
string myString;
};

intmain() {
MyClass myObj; // Creating an object of MyClass

myObj.myNum = 15;
myObj.myString = "Some text";

// Print attribute values
cout << myObj.myNum << "\n";
cout << myObj.myString;
return0;
}

Creación de varios objetos

Aquí hay un ejemplo de cómo crear múltiples objetos de la misma clase:

classCar {
public:
string brand;
};

intmain() {
// Create an object of Car
Car carObj1;
carObj1.brand = "BMW";

// Create another object of Car
Car carObj2;
carObj2.brand = "Ford";
// Print attribute values
cout << carObj1.brand "\n";
cout << carObj2.brand "\n";
return0;
}

Métodos de clase

Los métodos son como funciones que se definen dentro de una clase. C++ tiene dos tipos de métodos:dentro de la clase y fuera de la clase.

Método de clase interna

classMyClass {
public:
voidmyMethod() { // Method/function inside the class
cout << "Hello World!";
}
};

intmain() {
MyClass myObj; // Create an object of MyClass
myObj.myMethod(); // Call the method
return0;
}

Método de clase externa

classMyClass {
public:
voidmyMethod(); // Method declaration
};

// Method/function definition outside the class
void MyClass::myMethod() {
cout << "Hello World!";
}

intmain() {
MyClass myObj; // object creation
myObj.myMethod(); // Call the method
return0;
}

Constructores 

Un constructor es un método llamado automáticamente al crear un objeto. Tiene el mismo nombre que el nombre de la clase y no tiene ningún tipo de datos.

Por ejemplo:

classFir_Class {
public:
Fir_Class() { // Constructor
cout << "Hello World!";
}
};

intmain() {
Fir_Class myObj; // call the constructor
return0;
}

Especificadores de acceso 

Los especificadores de acceso definen el acceso de los miembros de la clase y las variables. C++ admite tres tipos de especificadores de acceso:

• Público: Los miembros de la clase y las variables son accesibles desde fuera de la clase.

• Privado: Los miembros de la clase y las variables son accesibles solo dentro de la clase y no fuera de la clase.

• Protegido: Los miembros de clase y las variables solo son accesibles en sus subclases.

Encapsulación 

La encapsulación lo ayuda a ocultar datos confidenciales de los usuarios. Aquí, usamos el especificador de acceso privado para declarar las variables y los métodos. Si desea permitir que otros lean o modifiquen esas variables y métodos, debe usar los métodos públicos get y set.

Por ejemplo:

#include <iostream>
usingnamespacestd;

classEmployee {
private:
int name;

public:
// Setter
voidsetName(int n) {
name= s;
}
// Getter
intgetName() {
return name;
}
};

intmain() {
Employee myObj;
myObj.setName("Bob");
cout << myObj.getName();
return0;
}

Herencia 

C++ admite la herencia, lo que le permite heredar los miembros y las variables de una clase a otra. La clase heredera es la clase secundaria y la otra es la clase principal. Debe usar el símbolo (:) para heredar:

// Parent class
classVehicle {
public:
string brand = "Ford";
voidsound() {
cout << "honk \n" ;
}
};

// Child class
classCar: public Vehicle {
public:
string model = "Mustang";
};

intmain() {
Car myCar;
myCar.sound();
cout << myCar.brand + " " + myCar.model;
return0;
}

Polimorfismo 

El polimorfismo especifica las "muchas formas". Es la capacidad de un solo mensaje para mostrarse en múltiples formularios y ocurre cuando tiene varias clases secundarias y una clase base.

Por ejemplo:

// Parent class
classAnimal {
public:
voidsound() {
cout << "The animal makes a sound \n" ;
}
};

// Child class
classPig : public Animal {
public:
voidsound() {
cout << "The pig says: wee wee \n" ;
}
};

// Derived class
classDog : public Animal {
public:
voidsound() {
cout << "The dog says: bow wow \n" ;
}
};
intmain() {
Animal ani;
Pig myPig;
Dog myDog;

ani.sound();
myPig.sound();
myDog.sound();
return0;
}

Gestión de archivos 

Puede usar una biblioteca fstream para manejar archivos. La biblioteca fstream consiste en un archivo de encabezado y .

#include

#include

ofstream: crear y escribir en los archivos.

ifstream: leer del archivo especificado.

fstream: combinación de los dos anteriores.

Crear y Escribir

#include <iostream>
#include <fstream>
usingnamespacestd;

intmain() {
// Create and open a text file
ofstream MyFile("filename.txt");

// Write to the file
MyFile << "content";

// Close the file
MyFile.close();
}

Lectura

// text string to output the text file
string myText;

// Read from the text file
ifstream MyReadFile("filename.txt");

// for reading the file line by line
while (getline (MyReadFile, myText)) {
// Output the text from the file
cout << myText;
}

// Close the file
MyReadFile.close();

Excepciones 

Mientras compila y ejecuta, es posible que encuentre errores. C++ le permite manejar y detectar estos errores mediante el manejo de excepciones. La siguiente es la sintaxis para el manejo de excepciones que incluye un bloque try-catch:

try {
// Block of code to try
throw exception; // Throw an exception when a problem arise
}
catch () {
// Block of code to handle errors
}

Por ejemplo:

try {
int age = 10;
if (age >= 20) {
cout << "you are old enough.";
} else {
throw505;
}
}
catch (int num) {
cout << "Access denied \n";
cout << "Error number: " << num;
}

Preprocesador

Los siguientes son algunos preprocesadores incorporados disponibles en C++ para varias funcionalidades.

#include <stdio.h> // Insert standard header file

#include "myfile.h" // Insert file in current directory

#define X some text // Replace X with some text

#define F(a,b) a+b // Replace F(1,2) with 1+2

#define X \

 some text // Multiline definition

#undef X // Remove definition

#if defined(X) // Conditional compilation (#ifdef X)

#else // Optional (#ifndef X or #if !defined(X))

#endif // Required after #if, #ifdef

Gestión de memoria dinámica

#include <memory> // Include memory (std namespace)
shared_ptr<int> x; // Empty shared_ptr to a integer on heap. Uses reference counting for cleaning up objects.
x = make_shared<int>(12); // Allocate value 12 on heap
shared_ptr<int> y = x; // Copy shared_ptr, implicit changes reference count to 2.
cout << *y; // Dereference y to print '12'
if (y.get() == x.get()) { // Raw pointers (here x == y)
cout << "Same";
}
y.reset(); // Eliminate one owner of object
if (y.get() != x.get()) {
cout << "Different";
}
if (y == nullptr) { // Can compare against nullptr (here returns true)
cout << "Empty";
}
y = make_shared<int>(15); // Assign new value
cout << *y; // Dereference x to print '15'
cout << *x; // Dereference x to print '12'
weak_ptr<int> w; // Create empty weak pointer
w = y; // w has weak reference to y.
if (shared_ptr<int> s = w.lock()) { // Has to be copied into a shared_ptr before usage
cout << *s;
}
unique_ptr<int> z; // Create empty unique pointers
unique_ptr<int> q;
z = make_unique<int>(16); // Allocate int (16) on heap. Only one reference allowed.
q = move(z); // Move reference from z to q.
if (z == nullptr){
cout << "Z null";
}
cout << *q;
shared_ptr<B> r;
r = dynamic_pointer_cast<B>(t); // Converts t to a shared_ptr<B>

Matemáticas de coma flotante

Debe incluir la biblioteca "cmath" para realizar tareas en números de punto flotante.

#include <cmath> // Include cmath (std namespace)

sin(x); cos(x); tan(x); // you can perform Trig functions, x (double) is in radians

asin(x); acos(x); atan(x); // Inverses

atan2(y, x); // atan(y/x)

sinh(x); cosh(x); tanh(x); // Hyperbolic sin, cos, tan functions

exp(x); log(x); log10(x); // e to the x, log base e, log base 10

pow(x, y); sqrt(x); // x to the y, square root

ceil(x); floor(x); // Round up or down (as a double)

fabs(x); fmod(x, y); // Absolute value, x mod y

iostream.h y iostream

#include <iostream> // Include iostream (std namespace)

cin >> x >> y; // Read words x and y (any type) from standard input

cout << "x=" << 3 << endl; // Write line to stdout

cerr << x << y << flush; // Write to stderr and flush

c = cin.get(); // c = getchar();

cin.get(c); // Read char

cin.getline(s, n, '\n'); // Read line into char s[n] to '\n' (default)

if (cin) // Good state (not EOF)?

// To read/write any type T:

istream& operator>>(istream& i, T& x) {i >> ...; x=...; return i;}

ostream& operator<<(ostream& o, const T& x) {return o << ...;}

Conclusión 

Hemos llegado al final de la hoja de trucos de referencia de C++. ¡Felicidades!

En esta referencia de C++, hemos cubierto casi todos los aspectos de C++ que cualquier principiante debe comprender al comenzar su carrera o prepararse para una próxima entrevista. Esta hoja de trucos de C++ para principiantes es un excelente recurso que puede consultar mientras desarrolla aplicaciones o antes de presentarse a una entrevista.

Esperamos que esta referencia de C++ lo ayude a comprender todo sobre C++ en profundidad.

¿Está interesado en ampliar sus conocimientos de C++? Consulte nuestra lista de los mejores cursos de C++.

La gente también está leyendo:

• Las mejores preguntas de entrevista de C++
• Diferencia entre C# y C++
• Mejor IDE de C++
• Los mejores libros de C++
• Los mejores cursos de Java
• Los mejores cursos de HTML
• Mejores cursos de desarrollo web
• Los mejores cursos de C