Cadenas en C++: fundamentos de std::string, métodos y trampas

std::string: texto que se gestiona solo

En la página anterior viste cómo los punteros inteligentes permiten que un objeto sea dueño de un recurso y lo libere automáticamente. std::string es esa misma idea aplicada al texto: posee un búfer de caracteres, lo hace crecer cuando añades algo y lo libera cuando la cadena sale de ámbito. Nunca llamas a new, nunca cuentas bytes y nunca te preocupas por un terminador nulo ausente.

Para usarlo, incluye <string>. La clase vive en el espacio de nombres std.

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

int main() {
    string name = "Ada";
    string greeting = "Hello, " + name + "!";

    cout << greeting << "\n";          // Hello, Ada!
    cout << "Length: " << name.size() << "\n";  // 3
    return 0;
}

Ese operador + hace trabajo real: reserva un búfer nuevo lo bastante grande para ambas partes y las copia dentro. Con un char* crudo tendrías que recurrir a strcpy y strcat y esperar que tu búfer fuera lo bastante grande. std::string hace desaparecer toda esa clase de errores.

Construir y unir cadenas

Puedes concatenar con +, pero el caballo de batalla para hacer crecer una cadena en su sitio es +=. Añade al búfer existente en lugar de producir una cadena totalmente nueva cada vez, lo cual importa dentro de bucles.

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

int main() {
    string sentence;                  // empieza vacía
    string words[] = {"the", "quick", "brown", "fox"};

    for (const string& w : words) {
        sentence += w;
        sentence += " ";
    }

    cout << sentence << "\n";         // the quick brown fox
    return 0;
}

Una sorpresa habitual: + necesita que al menos uno de los operandos ya sea un std::string. Dos literales de cadena son solo const char*, así que "a" + "b" no compila: no existe un operator+ para dos punteros crudos. Convierte uno de ellos en cadena primero:

string s = "a" + "b";              // error: can't add two const char*
string s = string("a") + "b";      // fine - left side is a std::string
string s = "a"s + "b";             // fine in C++14+, the "s" literal suffix

Fíjate en que esa última forma usa el sufijo s de <string> (using namespace std::string_literals;), que convierte un literal directamente en un std::string.

Acceder al interior de una cadena

Un std::string se comporta como un contenedor de char, así que puedes indexarlo, recorrerlo y pedirle trozos.

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

int main() {
    string word = "hello";

    cout << word[0] << "\n";          // h  - indexación con []
    cout << word.front() << " " << word.back() << "\n";  // h o
    cout << word.substr(1, 3) << "\n"; // ell - 3 caracteres desde el índice 1

    for (char c : word) {
        cout << c << '-';             // h-e-l-l-o-
    }
    cout << "\n";
    return 0;
}

substr(pos, len) devuelve una cadena totalmente nueva copiada del original; no modifica la fuente. Cuidado con los límites: word[10] sobre una cadena de 5 caracteres es comportamiento indefinido: no lanzará nada, simplemente lee basura. Si quieres un acceso comprobado que lance std::out_of_range, usa word.at(10) en lugar de word[10].

Otra trampa clásica: .size() devuelve un tipo sin signo (size_t). Escribir un bucle hacia atrás como for (size_t i = word.size() - 1; i >= 0; --i) nunca termina, porque un i sin signo nunca puede bajar de cero: da la vuelta y se convierte en un número enorme. Usa un índice con signo o reestructura la condición cuando necesites recorrer una cadena al revés.

Buscar y reemplazar

find localiza una subcadena o un carácter y devuelve el índice de inicio. Cuando el objetivo no está presente, devuelve la constante especial std::string::npos: compara siempre con ella en lugar de suponer que find devuelve -1.

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

int main() {
    string path = "report.final.pdf";

    size_t dot = path.find('.');               // 6 - primer punto
    size_t lastDot = path.rfind('.');          // 12 - último punto

    if (lastDot != string::npos) {
        cout << "Extension: " << path.substr(lastDot + 1) << "\n"; // pdf
        cout << "Base: " << path.substr(0, lastDot) << "\n";       // report.final
    }
    return 0;
}

Para cambiar texto en su sitio, replace(pos, len, text) intercambia un tramo por contenido nuevo (que puede tener otra longitud), e insert/erase añaden o quitan trozos:

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

int main() {
    string msg = "I like cats";

    msg.replace(7, 4, "dogs");   // reemplaza 4 caracteres en el índice 7
    cout << msg << "\n";          // I like dogs

    msg.insert(0, "Honestly, "); // añade al principio
    cout << msg << "\n";          // Honestly, I like dogs

    msg.erase(0, 10);            // elimina los primeros 10 caracteres
    cout << msg << "\n";          // I like dogs
    return 0;
}

Cadenas y números

El texto y los números no se convierten por sí solos: "42" son tres caracteres, no el entero 42. La biblioteca estándar te da funciones de conversión en ambos sentidos. Usa stoi, stod y compañía para analizar texto y convertirlo en números, y to_string para ir en la otra dirección.

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

int main() {
    string countText = "42";
    int count = stoi(countText) + 8;     // 50

    double price = 3.99;
    string label = "Price: $" + to_string(price);

    cout << count << "\n";               // 50
    cout << label << "\n";               // Price: $3.990000
    return 0;
}

Dos trampas aquí. Primera, stoi("abc") lanza std::invalid_argument, así que protege la entrada no confiable con try/catch. Segunda, to_string(3.99) da el 3.990000 completo: si necesitas control sobre la precisión y el formato, eso es trabajo de los flujos de cadenas (string streams), que es exactamente adonde vamos a continuación.

try {
    int n = std::stoi(userInput);
} catch (const std::invalid_argument&) {
    std::cout << "That wasn't a number.\n";
}

A continuación: entrada y salida

Has estado imprimiendo cadenas con cout todo este tiempo, pero leerlas de vuelta desde el usuario tiene sus propias sorpresas: cin >> name se detiene en el primer espacio, así que una línea completa como "Ada Lovelace" necesita std::getline en su lugar. La siguiente página cubre la entrada y salida en C++ como es debido: operadores de flujo, leer líneas enteras y mezclar >> con getline sin tropezar con saltos de línea sobrantes.