Programación

C y C++ Cheat Sheet – Hoja de Trucos

Ruben RG

Variables

Deben contener solo caracteres del alfabeto inglés, guión bajo (_) o dígitos; no deben iniciar por dígitos ni contener espacios en blanco o ser una palabra reservada.

tipo_dato identificador_variable;
tipo_dato identificador_variable = valor_inicial;

Tipos de Dato

  • char: caracteres (1 byte)
  • int: enteros (4 bytes)
  • float: decimales de 6-7 dígitos de precisión (4 bytes)
  • double: decimales de hasta 15 dígitos de precisión (8 bytes)
  • void: entidad sin valor

Sólo C++

  • bool: booleano
  • string: cadenas de texto (incluir <string>)

Modificadores:

  • short
  • long
  • signed
  • unsigned

Entrada / Salida

C

#include<stdio.h>

printf("cadena-de-formato", ...{lista-de-variables});
scanf("cadena-de-formato", ...{lista-de-direcciones-de-variables});

Especificadores de formato

EspecificadorDescripción
%cTipo b (char)
%dEnteros con signo
%fFlotantes
%lfDobles
%pPunteros
%sCadenas de texto
%uEnteros sin signo
%%Caracter %

C++

#include<iostream>

cout << "cadena" << variable;
cin >> variable;

Secuencias de escape:

Secuencia de escapeNombre
\bBackspace
\nNueva línea
\rRetorno de carro
\tTabulador horizontal
\vTabulador vertical
\\Backslash
\”Comillas dobles
\0NULL (carácter nulo)

Operadores

TipoOperadores
Aritméticos+, -, *, /, %
Relacionales<, >, <=, >=, ==, !=
Op. bit a bit (and, or exclusivo, or, despl. izq., despl. der., not)&, ^, |, <<, >>, ~
Lógicos&&, ||, !
Condicionales? :
De asignación=, +=, -=, *=, /=, %=, <<=, >>=
Otros, sizeof, &, *, ->, .

Cadenas de Texto

C

Son arreglos de caracteres terminados por el caracter nulo (\0)

#include <string.h>

char cadena[] = "Mi cadena de texto";
const char *cadena = "Mi cadena de texto";
char cadena[] = {'M', 'i', ' ', 'c', 'a', 'd', 'e', 'n', 'a', ' ', 'd', 'e', ' ', 't', 'e', 'x', 't', 'o'};
char cadena[tamaño];
char cadena[];

Funciones para manejo de cadenas

strlen(cadena)
scanf("%s", cadena);
scanf("%[^\n]s", cadena);
fgets(cadena, tamaño, stdin);

strcmp(cadena1, cadena2)
strcpy()
strcat()
strchr()
strstr()

C++

#include <string>

string cadena = "Mi cadena de texto";

Funciones para el manejo de cadenas

cadena[indice] == cadena.at(indice)
cadena.size() == cadena.length()

cadena1 + cadena2 == cadena1.append(cadena2)

cadena.push_back('caracter');
cadena.pop_back();

cadena1.insert(indice, cadena2);
cadena.erase(indice_inicio, largo);

cadena.substr(inicio, largo);

size_t cadena.find(cadena_busqueda, indice_inicio, numero_caracters_verificar);

cadena.swap()
cadena.resize()
cadena.clear()
cadena.strncmp()
cadena.strncpy()
cadena.strrchr()
cadena.strcat()
cadena.replace()
cadena.compare()
cadena.rfind()

Condicionales

if(condición) {
    // Instrucciones verdadero
} else {
    // Instrucciones falso
}

switch(expresión) {
    case valor_1:
        // Instrucciones valor_1
        break;
    case valor_2:
        // Instrucciones valor_2
        break;
    ...
    default:
        // Instrucciones default
}

Iterativos

for(inicio; condición; actualización) {
    // Instrucciones ciclo
}

while(condición) {
    // Instrucciones ciclo
}

do {
    // Instrucciones ciclo
} while(condición);

break; // rompe el ciclo y sale de él
continue; // continua la siguiente iteración

...
etiqueta:
...
goto etiqueta;
...

...
goto etiqueta;
...
etiqueta:
...

Arreglos

tipo_dato identificador_array[tamaño1][tamaño2]...[tamañoN];

tipo_dato identificador_array[] = {elemento1, elemento2, ..., elementoN};

Vectores (sólo C++)

#include <vector>

vector<tipo_dato> identificador;
vector<tipo_dato> identificador(tamaño, valor_inicial);
vector<tipo_dato> identificador = {elem1, elem2, ..., elemN};

vector<vector<tipo_dato>> identificador;

vector.push_back(elemento);
vector.insert(posicion, elemento);
vector.pop_back();
vector.erase();
vector[indice] == vector.at(indice)
vector.size()
vector.empty()
vector.clear()
vector.front()
vector.back()
vector.begin()

Referencias

tipo_dato identificador = valor;
tipo_dato &identificador_referencia = identificador

Punteros

tipo_dato identificador = valor;
tipo_dato *identificador_puntero = &identificador 

// & => obtiene la direccion de la variable
// *puntero => accesa / modifica el valor de la variable de la cual se almacena el valor
// puntero => accesa / modifica la direccion

Funciones

// Prototipo de funcion (declaración)
tipo_retorno identificador_funcion(lista_parametros);

// Definición de funciones
tipo_retorno identificador_funcion(lista_parametros) {
    // Bloque de instrucciones
}

Administración dinámica de memoria

malloc(size_t size);
tipo *ptr = (tipo*)malloc(sizeof(tipo) * tamaño);

calloc(size_t cantidad, ,size_t tamaño);
tipo *ptr = (tipo*)calloc(tamaño, sizeof(tipo));

realloc(void *ptr, size_t nuevo_tamaño);
ptr = realloc(ptr, sizeof(tipo) * nuevo_tamaño);

free(ptr);

Estructuras, Uniones y Enumeraciones

struct identificador_estructura {
    tipo_miembro_1 identificador1;
    tipo_miembro_2 identificador2;
    ...
    tipo_miembro_N identificadorN;
};

struct identificador_estructura {
    tipo_miembro_1 identificador1;
    tipo_miembro_2 identificador2;
    ...
    tipo_miembro_N identificadorN;
} var1, var2, ... varN;

struct estructura var1, var2, varN;

variable.miembro // Acceso a miembros
variable->miembro // Acceso a miembros, modo puntero

union identificador_union {
    tipo_miembro_1 identificador1;
    tipo_miembro_2 identificador2;
    ...
    tipo_miembro_N identificadorN;
};

union identificador_estructura {
    tipo_miembro_1 identificador1;
    tipo_miembro_2 identificador2;
    ...
    tipo_miembro_N identificadorN;
} var1, var2, ... varN;

union estructura var1, var2, varN;

variable.miembro // Acceso a miembros
variable->miembro // Acceso a miembros, modo puntero

enum identificador_enumeracion {
    valor1, valor2, ..., valorN = valor, ..., valorZ
};

enum idenficador_enumeracion var;
var = valorH;

enum class identificador_enumeracion {valor1, valor2, ..., valorN}

identificador_enumeracion var = identificador_enumeracion::valorJ

Administración y Acceso a Archivos

C

FILE *p_arch;
p_arch = fopen(ruta, modo);
    /* Modos
    w | wb
    a | ab
    r | rb
    */

fclose(p_arch);

fprintf(p_arch, "Cadena de Texto");
fputs()

fscanf();
fgets(variable, tamaño, p_arch);

fseek(p_arch, offset, posicion);
    /* Posiciones
    SEEK_END
    SEEK_SET
    SEEK_CUR
    */
rewind();

C++

#include <fstream>

fstream archivo("ruta", modo);
    /* Modos
    ios::in
    ios::out
    ios::binary
    ios::ate
    ios::app
    ios::trunc

    modo1 | modo2
   */

ofstream arch_out("ruta"); // ios:out
ifstream arch_in("ruta"); // ios:in

arch_out << "Cadena de Texto";

arch_in >> str_var;
getline(arch_in, str_var);

archivo.is_open()
archivo.close();
archivo.eof();

// Binarios:
size_t strLength = str.length();
file.write(reinterpret_cast<const char*>(&strLength),
    sizeof(strLength));
file.write(str.c_str(), strLength);

size_t strLength;
file.read(reinterpret_cast<char*>(&strLength), sizeof(strLength));
char* buffer = new char[strLength + 1];
char* buffer = new char[strLength + 1];
buffer[strLength] = '\0';
str = buffer;
delete[] buffer;

/* Eliminando archivos */  

#include <cstdio>
#include <iostream>
using namespace std;

int main()
{
    int status = remove("myfile.txt");
    if (status != 0) {
        perror("Error deleting file");
    }
    else {
        cout << "File successfully deleted" << endl;
    }
    return 0;
}

Programación Orientada a Objetos (POO)

Declaración

class NombreClase: public claseBase1, claseBase2, ... {
    // Herencia: https://www-w3schools-com.translate.goog/cpp/cpp_inheritance.asp?_x_tr_sl=en&_x_tr_tl=es&_x_tr_hl=es&_x_tr_pto=tc
    ambito: // Público, privado o protegido
        tipo miembro;
        tipo funcion_miembro_1(lista_parametros) {
            // Cuerpo de la función
            // Constructores: https://www-w3schools-com.translate.goog/cpp/cpp_constructors.asp?_x_tr_sl=en&_x_tr_tl=es&_x_tr_hl=es&_x_tr_pto=tc
        }
    public:
        NombreClase(lista_parametros):claseBase1(lista_parametros)... {
            // Cuerpo del constructor
            // Constructores: https://www-w3schools-com.translate.goog/cpp/cpp_constructors.asp?_x_tr_sl=en&_x_tr_tl=es&_x_tr_hl=es&_x_tr_pto=tc
        }
    ...
        friend tipo funcion_miembro_1(lista_parametros) {
            // Cuerpo de la función
            // Funciones amigas: https://www-w3schools-com.translate.goog/cpp/cpp_friend_function.asp?_x_tr_sl=en&_x_tr_tl=es&_x_tr_hl=es&_x_tr_pto=tc
        }
        virtual tipo funcion_miembro_1(lista_parametros) {
            // Cuerpo de la función
            // Funciones virtuales: https://www-w3schools-com.translate.goog/cpp/cpp_virtual_functions.asp?_x_tr_sl=en&_x_tr_tl=es&_x_tr_hl=es&_x_tr_pto=tc
        }
}

Dentro del cuerpo de las funciones se puede utlizar el puntero this, el cual apunta al objeto de la instancia actual, es decir, hace referencia a la instancia actual.

Objetos

NombreClase identificadorObjeto;
idenfiticadorObjeto.miembro1
identificadorObjeto.funcion_miembro_1(...)

NombreClase *identificadorObjeto = new NombreClase(...);
idenfiticadorObjeto->miembro1
identificadorObjeto->funcion_miembro_1(...)

delete identificadorObjeto;