Cómo escribir una API REST en C++ en 30 minutos: para principiantes

Introducción: Por qué C++ para API REST no da miedo

Muchos desarrolladores principiantes piensan que C++ es demasiado complejo para crear servicios web. Sin embargo, el C++ moderno (a partir del estándar C++11) proporciona herramientas potentes y elegantes para desarrollar API REST de alto rendimiento. En esta guía, crearemos en 30 minutos una API REST completa en C++ utilizando la biblioteca ligera Crow.

Analizaremos cómo configurar el servidor, manejar solicitudes GET y POST, trabajar con JSON y devolver datos. Al final del artículo, tendrá un prototipo funcional que puede usar como base para sus proyectos.

¿Qué es una API REST?

REST (Transferencia de Estado Representacional) es un estilo arquitectónico para crear servicios web. Las API REST utilizan métodos HTTP (GET, POST, PUT, DELETE) para gestionar recursos. Los datos generalmente se transmiten en formato JSON.

1. Preparación del entorno: instalación de bibliotecas

Para un inicio rápido, usaremos la biblioteca Crow, un framework web minimalista en C++ que no requiere configuración compleja. También necesitaremos una biblioteca para trabajar con JSON: nlohmann/json.

Instalación de dependencias (Linux/macOS)

# Instalamos los paquetes necesariossudo apt-get install libboost-all-dev cmake g++

# Descargamos Crow (versión de un solo archivo de cabecera)wget https://raw.githubusercontent.com/CrowCpp/Crow/master/include/crow.h

# Descargamos la biblioteca JSONwget https://github.com/nlohmann/json/releases/download/v3.11.2/json.hpp

Instalación de dependencias (Windows con MinGW)

Para Windows, use vcpkg:

vcpkg install crowvcpkg install nlohmann-json

2. Creamos un servidor HTTP simple en C++

Empecemos con un servidor básico que responderá a las solicitudes. Cree un archivo main.cpp:

#include "crow.h"

int main() {    crow::SimpleApp app;

    // Ruta GET simple    CROW_ROUTE(app, "/")([](){        return "¡Hola, mundo! ¡La API REST en C++ funciona!";    });

    // Iniciamos el servidor en el puerto 8080    app.port(8080).multithreaded().run();}

Compile y ejecute:

g++ -std=c++17 -pthread main.cpp -o api_server./api_server

Abra el navegador y vaya a http://localhost:8080. Verá un mensaje de bienvenida.

3. Agregamos manejo de JSON y operaciones CRUD

Ahora agregaremos soporte para JSON e implementaremos una base de datos simple en memoria para almacenar usuarios.

Incluimos soporte para JSON

#include "crow.h"#include "json.hpp"#include <vector>#include <string>

using json = nlohmann::json;

struct User {    int id;    std::string name;    std::string email;};

std::vector<User> users;int next_id = 1;

Ruta GET para obtener la lista de usuarios

CROW_ROUTE(app, "/users")([](){    json response = json::array();    for (const auto& user : users) {        response.push_back({            {"id", user.id},            {"name", user.name},            {"email", user.email}        });    }    return crow::response(response.dump());});

Ruta POST para crear un nuevo usuario

CROW_ROUTE(app, "/users").methods("POST"_method)([](const crow::request& req){    auto body = json::parse(req.body);

    User new_user;    new_user.id = next_id++;    new_user.name = body["name"];    new_user.email = body["email"];

    users.push_back(new_user);

    json response = {        {"id", new_user.id},        {"name", new_user.name},        {"email", new_user.email}    };

    return crow::response(201, response.dump());});

Ruta DELETE para eliminar un usuario

                
                

                    

                        Blogs                    
                    

                                                    
                                

                                    

                                        
                                    
                                    
Problemas de Go en LeetCode: cómo resolverlos y qué estudiar
                                
                            
                                                    
                                

                                    

                                        
                                    
                                    
Conversión de tipos de slices de interfaces en Go: análisis completo con ejemplos
                                
                            
                                            
                

                
                

                    

                        Book Recommendations                    
                    

                                                    
                                

                                    

                                        
                                    
                                    
Java y Kubernetes: Despliegue y orquestación de aplicaciones empresariales
                                
                            
                                                    
                                

                                    

                                        
                                    
                                    
Programación funcional en C# (.NET)
                                
                            
                                                    
                                

                                    

                                        
                                    
                                    
JavaScript de novato a ninja
                                
                            
                                                    
                                

                                    

                                        
                                    
                                    
Curso Acelerado de C++
                                
                            
                                            
                
            
    

  
Leer también
  

                
                  
                 Manejo de errores en Java: try/catch y más allá — guía completa
      
                
                  
                 .Contains() sin distinción de mayúsculas y minúsculas en C#: 5 mejores formas en 2025
      
                
                  
                 Memoria y recolector de basura en C++: mitos, realidad y gestión manual
      
                
                  
                 Docker y PHP: contenedorización de aplicaciones de nivel avanzado
      
                
                  
                 Referencias débiles a protocolos en Swift sin @objc: guía completa