try {
    // Code that may generate exceptions
}

try {
    // Code that may generate exceptions
} catch(type1 id1) {
    // Handle exceptions of type1
} catch(type2 id2) {
    // Handle exceptions of type2
} catch(type3 id3)
    // Etc...
} catch(typeN idN)
    // Handle exceptions of typeN
}
// Normal execution resumes here...

//: C01:Nonlocal2.cpp
// Illustrates exceptions.
#include <iostream>
using namespace std;

class Rainbow {
public:
  Rainbow() { cout << "Rainbow()" << endl; }
  ~Rainbow() { cout << "~Rainbow()" << endl; }
};

void oz() {
  Rainbow rb;
  for(int i = 0; i < 3; i++)
    cout << "there's no place like home" << endl;
  throw 47;
}

int main() {
  try {
    cout << "tornado, witch, munchkins..." << endl;
    oz();
  } catch(int) {
    cout << "Auntie Em! I had the strangest dream..."
         << endl;
  }
} ///:~

catch(...) {
    cout << "an exception was thrown" << endl;
}

catch(...) {
cout << "an exception was thrown" << endl;
// Deallocate your resource here, and then rethrow
    throw;
}

//: C01:Rawp.cpp
// Naked pointers.
#include <iostream>
#include <cstddef>
using namespace std;

class Cat {
public:
  Cat() { cout << "Cat()" << endl; }
  ~Cat() { cout << "~Cat()" << endl; }
};

class Dog {
public:
  void* operator new(size_t sz) {
    cout << "allocating a Dog" << endl;
    throw 47;
  }
  void operator delete(void* p) {
    cout << "deallocating a Dog" << endl;
    ::operator delete(p);
  }
};

class UseResources {
  Cat* bp;
  Dog* op;
public:
  UseResources(int count = 1) {
    cout << "UseResources()" << endl;
    bp = new Cat[count];
    op = new Dog;
  }
  ~UseResources() {
    cout << "~UseResources()" << endl;
    delete [] bp; // Array delete
    delete op;
  }
};

int main() {
  try {
    UseResources ur(3);
  } catch(int) {
    cout << "inside handler" << endl;
  }
} ///:~

UseResources()
Cat()
Cat()
Cat()
allocating a Dog
inside handler

//: C01:Wrapped.cpp
// Safe, atomic pointers.
#include <iostream>
#include <cstddef>
using namespace std;

// Simplified. Yours may have other arguments.
template<class T, int sz = 1> class PWrap {
  T* ptr;
public:
  class RangeError {}; // Exception class
  PWrap() {
    ptr = new T[sz];
    cout << "PWrap constructor" << endl;
  }
  ~PWrap() {
    delete[] ptr;
    cout << "PWrap destructor" << endl;
  }
  T& operator[](int i) throw(RangeError) {
    if(i >= 0 && i < sz) return ptr[i];
    throw RangeError();
  }
};

class Cat {
public:
  Cat() { cout << "Cat()" << endl; }
  ~Cat() { cout << "~Cat()" << endl; }
  void g() {}
};

class Dog {
public:
  void* operator new[](size_t) {
    cout << "Allocating a Dog" << endl;
    throw 47;
  }
  void operator delete[](void* p) {
    cout << "Deallocating a Dog" << endl;
    ::operator delete[](p);
  }
};

class UseResources {
  PWrap<Cat, 3> cats;
  PWrap<Dog> dog;
public:
  UseResources() { cout << "UseResources()" << endl; }
  ~UseResources() { cout << "~UseResources()" << endl; }
  void f() { cats[1].g(); }
};

int main() {
  try {
    UseResources ur;
  } catch(int) {
    cout << "inside handler" << endl;
  } catch(...) {
    cout << "inside catch(...)" << endl;
  }
} ///:~

Cat()
Cat()
Cat()
PWrap constructor
allocating a Dog
~Cat()
~Cat()
~Cat()
PWrap destructor
inside handler

void f();

void f() throw(...); // Not in C++

T pop() throw(logic_error);

Por lo tanto, ¿qué aspecto tiene una prueba unitaria? Demasiado a menudo los desarrolladores simplemente usan alguna entrada correcta para producir alguna salida esperada, que examinan visualmente. Existen dos peligros en este enfoque. Primero, los programas no siempre reciben sólo entradas correctas. Todos sabemos que deberíamos probar los límites de entrada de un programa, pero es duro pensar esto cuando está intentando simplemente hacer que las cosas funcionar. Si escribe primero la prueba para una función antes de comenzar a codificar, puede ponerse su traje de probador y preguntarse a si mismo, ¿qué haría posiblemente destrozar esto? Codificar una prueba que probará la función que escribirá no es erróneo, y luego ponerte el traje de desarrollador y hacerlo pasar. Escribirá mejor código que si no había escrito la prueba primero.

El segundo peligro es que esperar una salida visualmente es tedioso y propenso a error. La mayoría de cualquier tipo de cosas que un humano puede hacer un ordenador puede hacerlas, pero sin el error humano. Es mejor formular pruebas como colecciones de expresiones boolean y tener un programa de prueba que informa de cualquier fallo.

Por ejemplo, suponga que necesita construir una clase Fecha que tiene las siguientes propiedades:

Una fecha puede estar inicializada con una cadena (AAAAMMDD), 3 enteros (A, M, D), o nada (dando la fecha de hoy).

Un objecto fecha puede producir su año, mes y día o una cadena de la forma AAAAMMDD.

Todas las comparaciones relacionales están disponibles, además de calcular la duración entre dos fechas (en años, meses, y días).

Las fechas para ser comparadas necesitan poder extenderse un número arbitrario de siglos(por ejemplo, 16002200).

Su clase puede almacenar tres enteros que representan el año, mes y día. (Sólo asegúrese que el año es al menos de 16 bits de tamaño para satisfacer el último punto.) La interfaz de su clase Fecha se podría parecer a esto:

//: C02:Date1.h
// A first pass at Date.h.
#ifndef DATE1_H
#define DATE1_H
#include <string>

class Date {
public:
  // A struct to hold elapsed time:
  struct Duration {
    int years;
    int months;
    int days;
    Duration(int y, int m, int d)
    : years(y), months(m), days(d) {}
  };
  Date();
  Date(int year, int month, int day);
  Date(const std::string&);
  int getYear() const;
  int getMonth() const;
  int getDay() const;
  std::string toString() const;
   friend bool operator<(const Date&, const Date&);
   friend bool operator>(const Date&, const Date&);
   friend bool operator<=(const Date&, const Date&);
   friend bool operator>=(const Date&, const Date&);
   friend bool operator==(const Date&, const Date&);
   friend bool operator!=(const Date&, const Date&);
  friend Duration duration(const Date&, const Date&);
};
#endif // DATE1_H ///:~

Antes de que implemente esta clase, puede solidificar sus conocimientos de los requerimientos escribiendo el principio de un programa de prueba. Podría idear algo como lo siguiente:

//: C02:SimpleDateTest.cpp
//{L} Date
#include <iostream>
#include "Date.h" // From Appendix B
using namespace std;

// Test machinery
int nPass = 0, nFail = 0;
void test(bool t) { if(t) nPass++; else nFail++; }

int main() {
  Date mybday(1951, 10, 1);
  test(mybday.getYear() == 1951);
  test(mybday.getMonth() == 10);
  test(mybday.getDay() == 1);
  cout << "Passed: " << nPass << ", Failed: "
       << nFail << endl;
}
/* Expected output:
Passed: 3, Failed: 0
*/ ///:~

En este caso trivial, la función test( ) mantiene las variables globales nAprobar y nSuspender. La única revisión visual que hace es leer el resultado final. Si una prueba falla, un test( ) más sofisticado muestra un mensaje apropiado. El framework descrito más tarde en este capítulo tiene un función de prueba, entre otras cosas.

Puede ahora implementar la clase Fecha para hacer pasar estas pruebas, y luego puede proceder iterativamente hasta que se satisfagan todos los requerimientos. Escribiendo primero pruebas, es más probable que piense en casos límite que podrían destrozar su próxima implementación, y es más probable que escriba el código correctamente la primera vez. Como ejercicio podría realizar la siguiente versión de una prueba para la clase Fecha:

//: C02:SimpleDateTest2.cpp
//{L} Date
#include <iostream>
#include "Date.h"
using namespace std;

// Test machinery
int nPass = 0, nFail = 0;
void test(bool t) { if(t) ++nPass; else ++nFail; }

int main() {
  Date mybday(1951, 10, 1);
  Date today;
   Date myevebday("19510930");

  // Test the operators
  test(mybday < today);
  test(mybday <= today);
  test(mybday != today);
  test(mybday == mybday);
  test(mybday >= mybday);
  test(mybday <= mybday);
  test(myevebday < mybday);
  test(mybday > myevebday);
  test(mybday >= myevebday);
  test(mybday != myevebday);

  // Test the functions
  test(mybday.getYear() == 1951);
  test(mybday.getMonth() == 10);
  test(mybday.getDay() == 1);
  test(myevebday.getYear() == 1951);
  test(myevebday.getMonth() == 9);
  test(myevebday.getDay() == 30);
  test(mybday.toString() == "19511001");
  test(myevebday.toString() == "19510930");

  // Test duration
  Date d2(2003, 7, 4);
  Date::Duration dur = duration(mybday, d2);
  test(dur.years == 51);
  test(dur.months == 9);
  test(dur.days == 3);

  // Report results:
  cout << "Passed: " << nPass << ", Failed: "
       << nFail << endl;
} ///:~

Esta prueba puede ser desarrollada por completo. Por ejemplo, no hemos probado que duraciones grandes son manejadas correctamente. Pararemos aquí, pero coja la idea. La implementación entera para la case Fecha está disponible en los ficheros Date.h y Date.cpp en el apéndice.[23]

Algunas herramientas de pruebas unitarias automatizadas de C++ están disponibles en la World Wide Web para descargar, como CppUnit.[24] Nuestra intención aquí no es sólo presentar un mecanismo de prueba que sea fácil de usar, sino también fácil de entender internamente e incluso modificar si es necesario. Por lo tanto, en el espíritu de Hacer Lo Más Simple Que Podría Posiblemente Funcionar,[25] hemos desarrollado el Framework TestSuite, un espacio de nombres llamado TestSuite que contiene dos clases principales: Test y Suite.

La clase Test es una clase base abstracta de la cual deriva un objeto test. Tiene constancia del número de éxitos y fracasos y muestra el texto de cualquier condición de prueba que falla. Simplemente para sobreescribir la función run( ), que debería llamar en turnos a la macro test_() para cada condición de prueba boolean que defina.

Para definir una prueba para la clase Fecha usando el framework, puede heredar de Test como se muetra en el siguiente programa:

//: C02:DateTest.h
#ifndef DATETEST_H
#define DATETEST_H
#include "Date.h"
#include "../TestSuite/Test.h"

class DateTest : public TestSuite::Test {
  Date mybday;
  Date today;
  Date myevebday;
public:
  DateTest(): mybday(1951, 10, 1), myevebday("19510930") {}
  void run() {
    testOps();
    testFunctions();
    testDuration();
  }
  void testOps() {
    test_(mybday < today);
    test_(mybday <= today);
    test_(mybday != today);
    test_(mybday == mybday);
    test_(mybday >= mybday);
    test_(mybday <= mybday);
    test_(myevebday < mybday);
    test_(mybday > myevebday);
    test_(mybday >= myevebday);
    test_(mybday != myevebday);
  }
  void testFunctions() {
    test_(mybday.getYear() == 1951);
    test_(mybday.getMonth() == 10);
    test_(mybday.getDay() == 1);
    test_(myevebday.getYear() == 1951);
    test_(myevebday.getMonth() == 9);
    test_(myevebday.getDay() == 30);
    test_(mybday.toString() == "19511001");
    test_(myevebday.toString() == "19510930");
  }
  void testDuration() {
    Date d2(2003, 7, 4);
    Date::Duration dur = duration(mybday, d2);
    test_(dur.years == 51);
    test_(dur.months == 9);
    test_(dur.days == 3);
  }
};
#endif // DATETEST_H ///:~

Ejecutar la prueba es una sencilla cuestión de instaciación de un objeto DateTest y llamar a su función run( ):

//: C02:DateTest.cpp
// Automated testing (with a framework).
//{L} Date ../TestSuite/Test
#include <iostream>
#include "DateTest.h"
using namespace std;

int main() {
  DateTest test;
  test.run();
  return test.report();
}
/* Output:
Test "DateTest":
        Passed: 21,      Failed: 0
*/ ///:~

La función Test::report( ) muestra la salida previa y devuelve el número de fallos, de este modo es conveniente usarlo como valor de retorno desde el main( ).

La clase Test usa RTTI[26] para obtener el nombre de su clase(por ejemplo, DateTest) para el informe. Hay también una función setStream() si quiere enviar los resultados de la prueba a un fichero en lugar de la salida estándar (por defecto). Verá la implementación de la clase Test más tarde en este capítulo.

La macro test_( ) puede extraer el texto de la condición booleana que falla, junto con el nombre del fichero y número de línea.[27] Para ver lo que ocurre cuando un fallo aparece, puede insertar un error intencionado en el código, por ejemplo invirtiendo la condición en la primera llamda a test_( ) en DateTest::testOps( ) en el código de ejemplo previo. La salida indica exactamente que la prueba tenía un error y dónde ocurrió:

DateTest fallo: (mybday > hoy) , DateTest.h (línea 31) Test "DateTest": Passados: 20 Fallados: 1

Además de test_( ), el framework incluye las funciones succed_( ) y fail_( ), para casos donde una prueba Boolean no funcionará. Estas funciones se aplican cuando la clase que está probando podría lanzar excepciones. Durante la prueba, crear un conjunto de entrada que causará que la excepción aparezca. Si no, es un error y puede llamar a fail_( ) explicitamente para mostrar un mensaje y actualizar el contador de fallos. Si lanza la excecpión como se esperaba, llame a succeed_( ) para actualizar el contador de éxitos.

Para ilustrar, suponga que modificamos la especificación de los dos constructor no por defecto de Date para lanzar una excepción DateError (un tipo anidado dentro de Date y derivado de std::logic_error) si los parámetros de entrada no representa un fecha válida: Date(const string& s) throw(DateError); Date(int year, int month, int day) throw(DateError);

La función DateTest::run( ) puede ahora llamar a la siguiente función para probar el manejo de excepciones:

void testExceptions() {
try {
Date d(0,0,0);  // Invalid
fail_("Invalid date undetected in Date int ctor");
} catch(Date::DateError&) {
succeed_();
}
try {
Date d("");  // Invalid
fail_("Invalid date undetected in Date string ctor");
} catch(Date::DateError&) {
succeed_();
}
}

En ambos casos, si una excepción no se lanza, es un error. Fíjese que debe pasar manualmente un mensaje a fail_( ), pues no se está evaluando una expresión booleana.

Los proyectos reales contienen normalmente muchas clases, por lo tanto necesita un modo para agrupar pruebas para que pueda simplemente pulsar un solo botón para probar el proyecto entero.[28] La clase Suite recoge pruebas en una unidad funcional. Añada objetos Test a Suite con la función addTest( ), o puede incluir una suite existente entera con addSuite( ). Para ilustrar, el siguiente ejemplo reúna los programas del Capítulo 3 que usa la clase Test en una sola suite. Fíjese que este fichero aparecerá en el subdirectorio del Capítulo 3:

//: C03:StringSuite.cpp
//{L} ../TestSuite/Test ../TestSuite/Suite
//{L} TrimTest
// Illustrates a test suite for code from Chapter 3
#include <iostream>
#include "../TestSuite/Suite.h"
#include "StringStorage.h"
#include "Sieve.h"
#include "Find.h"
#include "Rparse.h"
#include "TrimTest.h"
#include "CompStr.h"
using namespace std;
using namespace TestSuite;

int main() {
    Suite suite("String Tests");
    suite.addTest(new StringStorageTest);
    suite.addTest(new SieveTest);
    suite.addTest(new FindTest);
    suite.addTest(new RparseTest);
    suite.addTest(new TrimTest);
    suite.addTest(new CompStrTest);
    suite.run();
    long nFail = suite.report();
    suite.free();
    return nFail;
}
/* Output:
s1 = 62345
s2 = 12345
Suite "String Tests"
====================
Test "StringStorageTest":
   Passed: 2   Failed: 0
Test "SieveTest":
   Passed: 50  Failed: 0
Test "FindTest":
   Passed: 9   Failed: 0
Test "RparseTest":
   Passed: 8   Failed: 0
Test "TrimTest":
   Passed: 11  Failed: 0
Test "CompStrTest":
   Passed: 8   Failed: 0
*/ ///:~

5 de los tests de más arriba están completamente contenidos en los ficheros de cabecera. TrimTest no lo está, porque contiene datos estáticos que deben estar definidos en un fichero de implementación. Las dos primeras líneas de salida son trazos de la prueba StringStorage. Debe dar a la suite un nombre como argumento del constructor. La función Suite::run( ) llama a Test::run( ) po cada una de las pruebas que tiene. Más de lo mismo pasa con Suite::report( ), excepto que puede enviar los informes de pruebas individuales a cadenas destinaciones diferentes mejor que el informe de la suite. Si la prueba pasa a addSuite( ) ya tiene un puntero de cadena asignado, que lo guarda. En otro caso, obtiene su cadena del objeto Suite. (Como con Test, hay un segundo argumento opcional para el constructor suite que no se presenta a std::cout.) El destructor para Suite no borra automáticamente los punteros contenidos en Test porque no necesitan residir en la pila; este es el trabajo de Suite::free( ).

El código del framework de pruebas es un subdirectorio llamado TestSuite en la distribución de código disponible en www.MindView.net. Para usarlo, incluya la ruta de búsqueda para el subdirectorio TestSuite en la ruta de búsqueda de la biblioteca. Aquí está la cabecera para Test.h:

//: TestSuite:Test.h
#ifndef TEST_H
#define TEST_H
#include <string>
#include <iostream>
#include <cassert>
using std::string;
using std::ostream;
using std::cout;

// fail_() has an underscore to prevent collision with
// ios::fail(). For consistency, test_() and succeed_()
// also have underscores.

#define test_(cond) \
  do_test(cond, #cond, __FILE__, __LINE__)
#define fail_(str) \
  do_fail(str, __FILE__, __LINE__)

namespace TestSuite {

class Test {
  ostream* osptr;
  long nPass;
  long nFail;
  // Disallowed:
  Test(const Test&);
  Test& operator=(const Test&);
protected:
  void do_test(bool cond, const string& lbl,
    const char* fname, long lineno);
  void do_fail(const string& lbl,
    const char* fname, long lineno);
public:
  Test(ostream* osptr = &cout) {
    this->osptr = osptr;
    nPass = nFail = 0;
  }
  virtual ~Test() {}
  virtual void run() = 0;
  long getNumPassed() const { return nPass; }
  long getNumFailed() const { return nFail; }
  const ostream* getStream() const { return osptr; }
  void setStream(ostream* osptr) { this->osptr = osptr; }
  void succeed_() { ++nPass; }
  long report() const;
  virtual void reset() { nPass = nFail = 0; }
};

} // namespace TestSuite
#endif // TEST_H ///:~

Hay tres funciones virtuales en la clase Test:

Un destructor virtual

La función reset( )

La función virtual pura run( )

Como se explicó en el Volumen 1, es un error eliminar un objeto derivado de la pila a través de un puntero base a menos que la clase base tenga un destructor virtual. Cualquier clase propuesta para ser una clase base (normalmente evidenciadas por la presencia de al menos una de las otras funciones virtuales) tendría un destructor virtual. La implementación por defecto de Test::reset( ) pone los contadores de éxitos y fallos a cero. Podría querer sobreescribir esta función para poner el estado de los datos en su objeto de test derivado; sólo asegúrese de llamar a Test::rest( ) explícitamente en su sobreescritura de modo que los contadores se reajusten. La función Test::run( ) es virtual pura ya que es necesario para sobreescribirla en su clase derivada.

Las macros test_( ) y fail_( ) pueden incluir la información disponible del nombre del fichero y el número de línea del preprocesador. Originalmente omitimos el guión bajo en los nombres, pero la macro fail colisiona con ios::fail( ), provocando errores de compilación.

Aquí está la implementación del resto de las funciones Test:

//: TestSuite:Test.cpp {O}
#include "Test.h"
#include <iostream>
#include <typeinfo>
using namespace std;
using namespace TestSuite;

void Test::do_test(bool cond, const std::string& lbl,
  const char* fname, long lineno) {
  if(!cond)
    do_fail(lbl, fname, lineno);
  else
    succeed_();
}

void Test::do_fail(const std::string& lbl,
  const char* fname, long lineno) {
  ++nFail;
  if(osptr) {
    *osptr << typeid(*this).name()
           << "failure: (" << lbl << ") , " << fname
           << " (line " << lineno << ")" << endl;
  }
}

long Test::report() const {
  if(osptr) {
    *osptr << "Test \"" << typeid(*this).name()
           << "\":\n\tPassed: " << nPass
           << "\tFailed: " << nFail
           << endl;
  }
  return nFail;
} ///:~

La clase Test lleva la cuenta del número de éxitos y fracasos además de la cadena donde quiere que Test::report( ) muestre los resultados. Las macros test_( ) y fail_() extraen la información del nombre del fichero actual y el número de línea del preprocesador y pasa el nombre del fichero a do_test( ) y el número de línea a do_fail( ), que hacen el mismo trabajo de mostrar un mensaje y actualizar el contador apropiado. No podemos pensar una buena razón para permitir copiar y asignar objetos de prueba, por lo que hemos rechazado estas operaciones para hacer sus prototipos privados y omitir el cuerpo de sus respectivas funciones.

Aquí está el fichero de cabecera para Suite:

//: TestSuite:Suite.h
#ifndef SUITE_H
#define SUITE_H
#include <vector>
#include <stdexcept>
#include "../TestSuite/Test.h"
using std::vector;
using std::logic_error;

namespace TestSuite {

class TestSuiteError : public logic_error {
public:
  TestSuiteError(const string& s = "")
  : logic_error(s) {}
};

class Suite {
  string name;
  ostream* osptr;
  vector<Test*> tests;
  void reset();
  // Disallowed ops:
  Suite(const Suite&);
  Suite& operator=(const Suite&);
public:
  Suite(const string& name, ostream* osptr = &cout)
  : name(name) { this->osptr = osptr; }
  string getName() const { return name; }
  long getNumPassed() const;
  long getNumFailed() const;
  const ostream* getStream() const { return osptr; }
  void setStream(ostream* osptr) { this->osptr = osptr; }
  void addTest(Test* t) throw(TestSuiteError);
  void addSuite(const Suite&);
  void run();  // Calls Test::run() repeatedly
  long report() const;
  void free();  // Deletes tests
};

} // namespace TestSuite
#endif // SUITE_H ///:~

La clase Suite tiene punteros a sus objetos Test en un vector. Fíjese en la especificación de la excepción en la función addTest( ). Cuando añada una prueba a una suite, Suite::addTest( ) verifique que el puntero que pasa no sea null; si es null, se lanza una excepción TestSuiteError. Puesto que esto hace imposible añadir un puntero null a una suite, addSuite( ) afirma esta condición en cada prueba, como hacen las otras funciones que atraviesan el vector de pruebas (vea la siguiente implementación). Copiar y asignar están desestimados como están en la clase Test.

//: TestSuite:Suite.cpp {O}
#include "Suite.h"
#include <iostream>
#include <cassert>
#include <cstddef>
using namespace std;
using namespace TestSuite;

void Suite::addTest(Test* t) throw(TestSuiteError) {
  // Verify test is valid and has a stream:
  if(t == 0)
    throw TestSuiteError("Null test in Suite::addTest");
  else if(osptr && !t->getStream())
    t->setStream(osptr);
  tests.push_back(t);
  t->reset();
}

void Suite::addSuite(const Suite& s) {
   for(size_t i = 0; i < s.tests.size(); ++i) {
     assert(tests[i]);
      addTest(s.tests[i]);
  }
}

void Suite::free() {
  for(size_t i = 0; i < tests.size(); ++i) {
    delete tests[i];
    tests[i] = 0;
  }
}

void Suite::run() {
  reset();
  for(size_t i = 0; i < tests.size(); ++i) {
    assert(tests[i]);
    tests[i]->run();
  }
}

long Suite::report() const {
  if(osptr) {
    long totFail = 0;
    *osptr << "Suite \"" << name
             << "\"\n=======";
    size_t i;
    for(i = 0; i < name.size(); ++i)
      *osptr << '=';
    *osptr << "=" << endl;
    for(i = 0; i < tests.size(); ++i) {
      assert(tests[i]);
      totFail += tests[i]->report();
    }
    *osptr << "=======";
    for(i = 0; i < name.size(); ++i)
      *osptr << '=';
    *osptr << "=" << endl;
    return totFail;
  }
  else
    return getNumFailed();
}

long Suite::getNumPassed() const {
  long totPass = 0;
  for(size_t i = 0; i < tests.size(); ++i) {
    assert(tests[i]);
    totPass += tests[i]->getNumPassed();
  }
  return totPass;
}

long Suite::getNumFailed() const {
  long totFail = 0;
  for(size_t i = 0; i < tests.size(); ++i) {
    assert(tests[i]);
    totFail += tests[i]->getNumFailed();
  }
  return totFail;
}

void Suite::reset() {
  for(size_t i = 0; i < tests.size(); ++i) {
    assert(tests[i]);
    tests[i]->reset();
  }
} ///:~

Usaremos el framework TestSuite donde sea pertinente a lo largo del resto de este libro.

Algunas veces es útil imprimir el código de cada sentencia cuando es ejecutada, o cout o trazar un fichero. Aquí esta una macro de preprocesaor para llevar a cabo esto:

#define TRACE(ARG) cout << #ARG << endl; ARG

Ahora puede ir a través y alrededor de las sentencias que traceé con esta macro. Sin embargo, esto puede introducir problemas. Por ejemplo, si coge la sentencia:

for(int i = 0; i < 100; i++) cout << i << endl;

y ponga ambas líneas dentro de la macro TRACE( ), obtiene esto:

TRACE(for(int i = 0; i < 100; i++)) TRACE( cout << i << endl;)

que se expande a esto:

cout << "for(int i = 0; i < 100; i++)" << endl; for(int i = 0; i < 100; i++) cout << "cout << i << endl;" << endl; cout << i << endl;

que no es exactamente lo que quiere. Por lo tanto, debe usar esta técnica cuidadosamente.

Lo siguiente es una variación en la macro TRACE( ):

#define D(a) cout << #a "=[" << a << "]" << endl;

Si quiere mostrar una expresión, simplemente póngala dentro de una llamada a D( ). La expresión se muestra, seguida de su valor ( asumiendo que hay un operador sobrecargado << para el tipo de resultado). Por ejemplo, puede decir D(a + b). Puede usar esta macro en cualquier momento que quiera comprobar un valor intermedio.

Estas dos macros representan las dos cosas fundamentales que hace con un depurador: trazar la ejecución de código y mostrar valores. Un buen depurador es una herramienta de productividad excelente, pero a veces los depuradores no están disponibles, o no es conveniente usarlos. Estas técnicas siempre funcionan, sin tener en cuenta la situación.

ADVERTENCIA: Esta sección y la siguiente contienen código que está oficialmente sin aprobación por el Estándar C++. En particular, redefinimos cout y new mediante macros, que puede provocar resultados sorprendentes si no tiene cuidado. Nuestros ejemplos funcionan en todos los compiladores que usamos, comoquiera, y proporcionan información útil. Este es el único lugar en este libro donde nos desviaremos de la inviolabilidad de la práctica de codificar cumpliendo el estándar. ¡Úsalo bajo tu propio riesgo! Dese cuenta que para este trabajo, usar delcaraciones debe ser realizado, para que cout no esté prefijado por su nombre de espacio, p.e. std::cout no funcionará.

El siguiente código crea fácilmente un fichero de seguimiento y envía todas las salidas que irían normalmente a cout a ese fichero. Todo lo que debe hacer es #define TRACEON e incluir el fichero de cabecera (por supuesto, es bastante fácil sólo escribir las dos líneas claves correctamente en su fichero):

//: C03:Trace.h
// Creating a trace file.
#ifndef TRACE_H
#define TRACE_H
#include <fstream>

#ifdef TRACEON
std::ofstream TRACEFILE__("TRACE.OUT");
#define cout TRACEFILE__
#endif

#endif // TRACE_H ///:~

Aquí esta una prueba sencilla del fichero anterior:

//: C03:Tracetst.cpp {-bor}
#include <iostream>
#include <fstream>
#include "../require.h"
using namespace std;

#define TRACEON
#include "Trace.h"

int main() {
  ifstream f("Tracetst.cpp");
  assure(f, "Tracetst.cpp");
  cout << f.rdbuf(); // Dumps file contents to file
} ///:~

Porque cout ha sido textualmente convertido en algo más por Trace.h, todas las sentencias cout en su programa ahora envían información al fichero de seguimiento. Esto es una forma conveniente de capturar su salida en un fichero, en caso de que su sistema operativo no haga una fácil redirección de la salida.

Las siguientes técnicas sencillas de depuración están explicadas en el Volumen 1:

1. Para comprobar los límites de un array, usa la plantilla Array en C16:Array3.cpp del Volumen 1 para todos los arrays. Puede desactivar la comprobación e incrementar la eficiencia cuando esté listo para enviar. (Aunque esto no trata con el caso de coger un puntero a un array.)

2. Comprobar destructores no virtuales en clases base. Seguirle la pista a new/delete y malloc/free

Los problemas comunes con la asignación de memoria incluyen llamadas por error a delete para memoria que no está libre, borrar el espacio libre más de una vez, y más a menudo, olvidando borrar un puntero. Esta sección discute un sistema que puede ayudarle a localizar estos tipos de problemas.

Como cláusula adicional de exención de responsabilidad más allá de la sección precedente: por el modo que sobrecargamos new, la siguiente técnica puede no funcionar en todas las plataformas, y funcionará sólo para programas que no llaman explicitamente al operador de función new( ). Hemos sido bastante cuidadosos en este libro para presentar sólo código que se ajuste completamente al Estándar C++, pero en este ejemplo estamos haciendo una excepción por las siguientes razones:

1. A pesar de que es técnicamente ilegal, funciona en muchos compiladores.[29]

2. Ilustramos algunos pensamientos útiles en el trascurso del camino.

Para usar el sistema de comprobación de memoria, simplemente incluya el fichero de cabecera MemCheck.h, conecte el fichero MemCheck.obj a su aplicación para interceptar todas las llamadas a new y delete, y llame a la macro MEM_ON( ) (se explica más tarde en esta sección) para iniciar el seguimiento de la memoria. Un seguimiento de todas las asignaciones y desasignaciones es impreso en la salida estándar (mediante stdout). Cuando use este sistema, todas las llamadas a new almacenan información sobre el fichero y la línea donde fueron llamados. Esto está dotado usando la sintaxis de colocación para el operador new.[30] Aunque normalmente use la sintaxis de colocación cuando necesite colocar objetos en un punto de memoria específico, puede también crear un operador new( ) con cualquier número de argumentos. Esto se usa en el siguiente ejemplo para almacenar los resultados de las macros __FILE__ y __LINE__ cuando se llama a new:

//: C02:MemCheck.h
#ifndef MEMCHECK_H
#define MEMCHECK_H
#include <cstddef>  // For size_t

// Usurp the new operator (both scalar and array versions)
void* operator new(std::size_t, const char*, long);
void* operator new[](std::size_t, const char*, long);
#define new new (__FILE__, __LINE__)

extern bool traceFlag;
#define TRACE_ON() traceFlag = true
#define TRACE_OFF() traceFlag = false

extern bool activeFlag;
#define MEM_ON() activeFlag = true
#define MEM_OFF() activeFlag = false

#endif // MEMCHECK_H ///:~

Es importante incluir este fichero en cualquier fichero fuente en el que quiera seguir la actividad de la memoria libre, pero inclúyalo al final (después de sus otras directivas #include). La mayoría de las cabeceras en la biblioteca estándar son plantillas, y puesto que la mayoría de los compiladores usan el modelo de inclusión de compilación de plantilla (significa que todo el código fuente está en las cabeceras), la macro que reemplaza new en MemCheck.h usurpará todas las instancias del operador new en el código fuente de la biblioteca (y casi resultaría en errores de compilación). Además, está sólo interesado en seguir sus propios errores de memoria, no los de la biblioteca.

En el siguiente fichero, que contiene la implementación del seguimiento de memoria, todo está hecho con C estándar I/O más que con iostreams C++. No debería influir, puesto que no estamos interfiriendo con el uso de iostream en la memoria libre, pero cuando lo intentamos, algunos compiladores se quejaron. Todos los compiladores estaban felices con la versión <cstdio>.

//: C02:MemCheck.cpp {O}
#include <cstdio>
#include <cstdlib>
#include <cassert>
#include <cstddef>
using namespace std;
#undef new

// Global flags set by macros in MemCheck.h
bool traceFlag = true;
bool activeFlag = false;

namespace {

// Memory map entry type
struct Info {
  void* ptr;
  const char* file;
  long line;
};

// Memory map data
const size_t MAXPTRS = 10000u;
Info memMap[MAXPTRS];
size_t nptrs = 0;

// Searches the map for an address
int findPtr(void* p) {
  for(size_t i = 0; i < nptrs; ++i)
    if(memMap[i].ptr == p)
      return i;
  return -1;
}

void delPtr(void* p) {
  int pos = findPtr(p);
  assert(pos >= 0);
  // Remove pointer from map
  for(size_t i = pos; i < nptrs-1; ++i)
    memMap[i] = memMap[i+1];
  --nptrs;
}

// Dummy type for static destructor
struct Sentinel {
  ~Sentinel() {
    if(nptrs > 0) {
      printf("Leaked memory at:\n");
      for(size_t i = 0; i < nptrs; ++i)
        printf("\t%p (file: %s, line %ld)\n",
          memMap[i].ptr, memMap[i].file, memMap[i].line);
    }
    else
      printf("No user memory leaks!\n");
  }
};

// Static dummy object
Sentinel s;

} // End anonymous namespace

// Overload scalar new
void*
operator new(size_t siz, const char* file, long line) {
  void* p = malloc(siz);
  if(activeFlag) {
    if(nptrs == MAXPTRS) {
      printf("memory map too small (increase MAXPTRS)\n");
      exit(1);
    }
    memMap[nptrs].ptr = p;
    memMap[nptrs].file = file;
    memMap[nptrs].line = line;
    ++nptrs;
  }
  if(traceFlag) {
    printf("Allocated %u bytes at address %p ", siz, p);
    printf("(file: %s, line: %ld)\n", file, line);
  }
  return p;
}

// Overload array new
void*
operator new[](size_t siz, const char* file, long line) {
  return operator new(siz, file, line);
}

// Override scalar delete
void operator delete(void* p) {
  if(findPtr(p) >= 0) {
    free(p);
    assert(nptrs > 0);
    delPtr(p);
    if(traceFlag)
      printf("Deleted memory at address %p\n", p);
  }
  else if(!p && activeFlag)
    printf("Attempt to delete unknown pointer: %p\n", p);
}

// Override array delete
void operator delete[](void* p) {
  operator delete(p);
} ///:~

Las banderas booleanas de traceFalg y activeFlag son globales, por lo que pueden ser modificados en su código por las macros TRACE_ON( ), TRACE_OFF( ), MEM_ON( ), y MEM_OFF( ). En general, encierre todo el código en su main( ) dentro una pareja MEM_ON( )-MEM_OFF( ) de modo que la memoria sea siempre trazada. Trazar, que repite la actividad de las funciones de sustitución por el operador new( ) y el operador delete( ), es por defecto, pero puede desactivarlo con TRACE_OFF( ). En cualquier caso, los resultados finales son siempre impresos (vea la prueba que se ejecuta más tarde en este capítulo).

La facilidad MemCheck rastrea la memoria guardando todas las direcciones asignadas por el operador new( ) en un array de estructuras Info, que también tiene el nombre del fichero y el número de línea donde la llamada new se encuentra. Para prevenir la colisión con cualquier nombre que haya colocado en el espacio de nombres global, tanta información como sea posible se guarda dentro del espacio de nombre anónimo. La clase Sentinel existe únicamente para llamar a un destructor de objetos con estático cuando el programa termina. Este destructor inspecciona memMap para ver si algún puntero está esperando a ser borrado (indicando una perdida de memoria).

Nuestro operador new( ) usa malloc( ) para conseguir memoria, y luego añade el puntero y su información de fichero asociado a memMap. La función de operador delete( ) deshace todo el trabajo llamando a free( ) y decrementando nptrs, pero primero se comprueba para ver si el puntero en cuestión está en el mapa en el primer lugar. Si no es así, o reintenta borrar una dirección que no está en el almacén libre, o re intenta borrar la que ya ha sido borrada y eliminada del mapa. La variable activeFlag es importante aquí porque no queremos procesar ninguna desasignación de alguna actividad del cierre del sistema. Llamando a MEM_OFF( ) al final de su código, activeFlag será puesta a falso, y posteriores llamadas para borrar serán ignoradas. (Está mal en un programa real, pero nuestra intención aquí es encontrar agujeros, no está depurando la biblioteca.) Por simplicidad, enviamos todo el trabajo por array new y delete a sus homólogos escalares.

Lo siguiente es un test sencillo usando la facilidad MemCheck:

//: C02:MemTest.cpp
//{L} MemCheck
// Test of MemCheck system.
#include <iostream>
#include <vector>
#include <cstring>
#include "MemCheck.h"   // Must appear last!
using namespace std;

class Foo {
  char* s;
public:
  Foo(const char*s ) {
    this->s = new char[strlen(s) + 1];
    strcpy(this->s, s);
  }
  ~Foo() { delete [] s; }
};

int main() {
  MEM_ON();
  cout << "hello" << endl;
  int* p = new int;
  delete p;
  int* q = new int[3];
  delete [] q;
  int* r;
  delete r;
  vector<int> v;
  v.push_back(1);
  Foo s("goodbye");
  MEM_OFF();
} ///:~

Este ejemplo verifica que puede usar MemCheck en presencia de streams, contenedores estándar, y clases que asignan memoria en constructores. Los punteros p y q son asignados y desasignados sin ningún problema, pero r no es un puntero de pila válido, así que la salida indica el error como un intento de borrar un puntero desconocido:

hola Asignados 4 bytes en la dirección 0xa010778 (fichero: memtest.cpp, línea: 25) Deleted memory at address 0xa010778 Asignados 12 bytes en la dirección 0xa010778 (fichero: memtest.cpp, línea: 27) Memoria borrada en la dirección 0xa010778 Intento de borrar puntero desconocido: 0x1 Asignados 8 bytes en la dirección 0xa0108c0 (fichero: memtest.cpp, línea: 14) Memoria borrada en la dirección 0xa0108c0 ¡No hay agujeros de memoria de usuario!

A causa de la llamada a MEM_OFF( ), no se procesan posteriores llamadas al operador delete( ) por vector o ostream. Todavía podría conseguir algunas llamadas a delete realizadas dsede reasignaciones por los contenedores.

Si llama a TRACE_OFF( ) al principio del programa, la salida es

Hola Intento de borrar puntero desconocido: 0x1 ¡No hay agujeros de memoria de usuario!

Uno de los aspectos más valiosos y convenientes de los string en C++ es que crecen cuando lo necesitan, sin intervención por parte del programador. No solo hace el código de manejo del string sea inherentemente mas confiable, además elimina por completo las tediosas funciones "caseras" para controlar los limites del almacenamiento en donde nuestra cadena reside. Por ejemplo, si crea un objeto string e inicializa este string con 50 copias de "X", y después copia en el 50 copias de "Zowie", el objeto, por sí mismo, readecua suficiente almacenamiento para acomodar el crecimiento de los datos. Quizás en ningún otro lugar es más apreciada esta propiedad que cuando las cadenas manipuladas por su código cambian de tamaño y no sabe cuan grande puede ser este cambio. La función miembro append() e insert() de string reubican de manera transparente el almacenamiento cuando un string crece:

//: C03:StrSize.cpp
#include <string>
#include <iostream>
using namespace std;

int main() {
  string bigNews("I saw Elvis in a UFO. ");
  cout << bigNews << endl;
  // How much data have we actually got?
  cout << "Size = " << bigNews.size() << endl;
  // How much can we store without reallocating?
  cout << "Capacity = " << bigNews.capacity() << endl;
  // Insert this string in bigNews immediately
  // before bigNews[1]:
  bigNews.insert(1, " thought I");
  cout << bigNews << endl;
  cout << "Size = " << bigNews.size() << endl;
  cout << "Capacity = " << bigNews.capacity() << endl;
  // Make sure that there will be this much space
  bigNews.reserve(500);
  // Add this to the end of the string:
  bigNews.append("I've been working too hard.");
  cout << bigNews << endl;
  cout << "Size = " << bigNews.size() << endl;
  cout << "Capacity = " << bigNews.capacity() << endl;
} ///:~

Aquí la salida desde un compilador cualquiera:

I saw Elvis in a UFO.
Size = 22
Capacity = 31
I thought I saw Elvis in a UFO.
Size = 32
Capacity = 47
I thought I saw Elvis in a UFO. I've been
working too hard.
Size = 59
Capacity = 511

Este ejemplo demuestra que aunque puede ignorar con seguridad muchas de las responsabilidades de reserva y gestión de la memoria que tus string ocupan, C++ provee a los string con varias herramientas para monitorizar y gestionar su tamaño. Nótese la facilidad con la que hemos cambiado el tamaño de la memoria reservada para los string. La función size() retorna el numero de caracteres actualmente almacenados en el string y es idéntico a la función miembro lenght(). La función capacity() retorna el tamaño de la memoria subyacente actual, es decir, el número de caracteres que el string puede almacenar sin tener que reservar más memoria. La función reserve() es una optimización del mecanismo que indica su intención de especificar cierta cantidad de memoria para un futuro uso; capacity() siempre retorna un valor al menos tan largo como la ultima llamada a reserve(). La función resize() añade espacio si el nuevo tamaño es mayor que el tamaño actual del string; sino trunca el string. (Una sobrecarga de resize() puede especificar una adición diferente de caracteres).

La manera exacta en que las funciones miembro de string reservan espacio para sus datos depende de la implementación de la librería. Cuando testeamos una implementación con el ejemplo anterior, parece que se hacia una reserva de una palabra de memoria (esto es, un entero) dejando un byte en blanco entre cada una de ellas. Los arquitectos de la clase string se esforzaron para poder mezclar el uso de las cadenas de caracteres de C y los objetos string, por lo que es probable por lo que se puede observar en StrSize.cpp, en esta implementación en particular, el byte esté añadido para acomodar fácilmente la inserción de un terminador nulo.

La función insert() es particularmente útil por que te evita el tener que estar seguro de que la inserción de caracteres en un string no sobrepasa el espacio reservado o sobrescribe los caracteres que inmediatamente siguientes al punto de inserción. El espacio crece y los caracteres existentes se mueven graciosamente para acomodar a los nuevos elementos. A veces, puede que no sea esto exactamente lo que quiere. Si quiere que el tamaño del string permanezca sin cambios, use la función replace() para sobrescribir los caracteres. Existe un número de versiones sobrecargadas de replace(), pero la más simple toma tres argumentos: un entero indicando donde empezar en el string, un entero indicando cuantos caracteres para eliminar del string original, y el string con el que reemplazaremos (que puede ser diferente en numero de caracteres que la cantidad eliminada). Aquí un ejemplo simple:

//: C03:StringReplace.cpp
// Simple find-and-replace in strings.
#include <cassert>
#include <string>
using namespace std;

int main() {
  string s("A piece of text");
  string tag("$tag$");
  s.insert(8, tag + ' ');
  assert(s == "A piece $tag$ of text");
  int start = s.find(tag);
  assert(start == 8);
  assert(tag.size() == 5);
  s.replace(start, tag.size(), "hello there");
  assert(s == "A piece hello there of text");
} ///:~

Tag es insertada en s (notese que la inserción ocurre antes de que el valor indicando el punto de inserción y de que el espacio extra haya sido añadido despues de Tag), y entonces es encontrada y reemplazada.

Debería cerciorarse de que ha encontrado algo antes de realizar el replace(). En los ejemplos anteriores se reemplaza con un char*, pero existe una versión sobrecargada que reemplaza con un string. Aqui hay un ejempl más completo de demostración de replace():

//: C03:Replace.cpp
#include <cassert>
#include <cstddef>  // For size_t
#include <string>
using namespace std;

void replaceChars(string& modifyMe,
  const string& findMe, const string& newChars) {
  // Look in modifyMe for the "find string"
  // starting at position 0:
  size_t i = modifyMe.find(findMe, 0);
  // Did we find the string to replace?
  if(i != string::npos)
    // Replace the find string with newChars:
    modifyMe.replace(i, findMe.size(), newChars);
}

int main() {
  string bigNews = "I thought I saw Elvis in a UFO. "
                   "I have been working too hard.";
  string replacement("wig");
  string findMe("UFO");
  // Find "UFO" in bigNews and overwrite it:
  replaceChars(bigNews, findMe, replacement);
  assert(bigNews == "I thought I saw Elvis in a "
         "wig. I have been working too hard.");
} ///:~

Si replace() no encuentra la cadena buscada, retorna un string::npos. El dato miembro npos es una constante estatica de la clase string que representa una posición de carácter que no existe[33]. ^[3]

A diferencia de insert(), replace() no aumentará el espacio de alamcenamiento de string si copia nuevos caracteres en el medio de una serie de elementos de array existentes. Sin embargo, sí que cerecerá su espacio si es necesario, por ejemplo, cuando hace un "reemplazamiento" que pueda expandir el string más allá del final de la memoria reservada actual. Aquí un ejemplo:

//: C03:ReplaceAndGrow.cpp
#include <cassert>
#include <string>
using namespace std;

int main() {
  string bigNews("I have been working the grave.");
  string replacement("yard shift.");
  // The first argument says "replace chars
  // beyond the end of the existing string":
  bigNews.replace(bigNews.size() - 1,
    replacement.size(), replacement);
  assert(bigNews == "I have been working the "
         "graveyard shift.");
} ///:~

La llamada a replace() empieza "reemplazando" más allá del final del array existente, que es equivalente a la operación append(). Nótese que en este ejemplo replace() expande el array coherentemente.

Puede que haya estado buscando a través del capítulo; intentando hacer algo relativamente fácil como reemplazar todas las ocurrencias de un carácter con diferentes caracteres. Al buscar el material previo sobre reemplazar, puede que haya encontrado la respuesta, pero entonces ha empezaro viendo grupos de caracteres y contadores y otras cosas que parecen un poco demasiado complejas. ¿No tiene string una manera para reemplazar un carácter con otro simplemente?

Puede escribir fácilmente cada funcin usando las funciones miembro find() y replace() como se muestra acontinuacion.

//: C03:ReplaceAll.h
#ifndef REPLACEALL_H
#define REPLACEALL_H
#include <string>

std::string& replaceAll(std::string& context,
  const std::string& from, const std::string& to);
#endif // REPLACEALL_H ///:~

//: C03:ReplaceAll.cpp {O}
#include <cstddef>
#include "ReplaceAll.h"
using namespace std;

string& replaceAll(string& context, const string& from,
  const string& to) {
  size_t lookHere = 0;
  size_t foundHere;
  while((foundHere = context.find(from, lookHere))
    != string::npos) {
    context.replace(foundHere, from.size(), to);
    lookHere = foundHere + to.size();
  }
  return context;
} ///:~

La versión de find() usada aquí toma como segundo argumento la posición donde empezar a buscar y retorna string::npos si no lo encuentra. Es importante avanzar en la posición contenida por la variable lookHere pasada como subcadena, en caso de que from es una subcadena de to. El siguiente programa comprueba la funcion replaceAll():

//: C03:ReplaceAllTest.cpp
//{L} ReplaceAll
#include <cassert>
#include <iostream>
#include <string>
#include "ReplaceAll.h"
using namespace std;

int main() {
  string text = "a man, a plan, a canal, Panama";
  replaceAll(text, "an", "XXX");
  assert(text == "a mXXX, a plXXX, a cXXXal, PXXXama");
} ///:~

Como puede comprobar, la clase string por ella sola no resuelve todos los posibles problemas. Muchas soluciones se han dejado en los algoritmos de la librería estándar^[4] por que la clase string puede parece justamente como una secuencia STL(gracias a los iteradores descritos antes). Todos los algoritmos genéricos funcionan en un "rango" de elementos dentro de un contenedor. Generalmente este rango es justamente desde el principio del contenedor hasta el final. Un objeto string se parece a un contenedor de caracteres: para obtener el principio de este rango use string::begin(), y para obtener el final del rango use string::end(). El siguiente ejemplomuestra el uso del algoritmo replace() para reemplazar todas las instancias de un determinado carácter "X" con "Y"

//: C03:StringCharReplace.cpp
#include <algorithm>
#include <cassert>
#include <string>
using namespace std;

int main() {
  string s("aaaXaaaXXaaXXXaXXXXaaa");
  replace(s.begin(), s.end(), 'X', 'Y');
  assert(s == "aaaYaaaYYaaYYYaYYYYaaa");
} ///:~

Nótese que esta función replace() no es llamada como función miembro de string. Además, a diferencia de la función string::replace(), que solo realiza un reemplazo, el algoritmo replace() reemplaza todas las instancias de un carácter con otro.

El algoritmo replace() solo funciona con objetos individuales (en este caso, objetos char) y no reemplazará arreglos constantes o objetos string. Desde que un string se copmporta como una secuencia STL, un conjunto de algoritmos pueden serle aplicados, que resolverán otros problemas que las funciones miembro de string no resuelven.

Uno de los descubrimientos más deliciosos que esperan al programador de C que está aprendiendo sobre el manejo de cadenas en C++, es lo simple que es combinar y añadir string usando los operadores operator+ y operator+=. Estos operadores hacen combinaciones de cadenas sintacticamente parecidas a la suma de datos numéricos:

//: C03:AddStrings.cpp
#include <string>
#include <cassert>
using namespace std;

int main() {
  string s1("This ");
  string s2("That ");
  string s3("The other ");
  // operator+ concatenates strings
  s1 = s1 + s2;
  assert(s1 == "This That ");
  // Another way to concatenates strings
  s1 += s3;
  assert(s1 == "This That The other ");
  // You can index the string on the right
  s1 += s3 + s3[4] + "ooh lala";
  assert(s1 == "This That The other The other oooh lala");
} ///:~

Usar los operadores operator+ y operator+= es una manera flexible y conveniente de combinar los datos de las cadenas. En la parte derecha de la sentencia, puede usar casi cualquier tipo que evalúe a un grupo de uno o más caracteres.

Si necesita buscar en una cadena desde el final hasta el principio (para encontrar datos en orden "último entra / primero sale"), puede usar la función miembro de string rfind().

//: C03:Rparse.h
#ifndef RPARSE_H
#define RPARSE_H
#include <cstddef>
#include <string>
#include <vector>
#include "../TestSuite/Test.h"
using std::size_t;
using std::string;
using std::vector;

class RparseTest : public TestSuite::Test {
  // To store the words:
  vector<string> strings;
public:
  void parseForData() {
    // The ';' characters will be delimiters
    string s("now.;sense;make;to;going;is;This");
    // The last element of the string:
    int last = s.size();
    // The beginning of the current word:
    size_t current = s.rfind(';');
    // Walk backward through the string:
    while(current != string::npos) {
      // Push each word into the vector.
      // Current is incremented before copying
      // to avoid copying the delimiter:
      ++current;
      strings.push_back(s.substr(current, last - current));
      // Back over the delimiter we just found,
      // and set last to the end of the next word:
      current -= 2;
      last = current + 1;
      // Find the next delimiter:
      current = s.rfind(';', current);
    }
    // Pick up the first word -- it's not
    // preceded by a delimiter:
    strings.push_back(s.substr(0, last));
  }
  void testData() {
    // Test them in the new order:
    test_(strings[0] == "This");
    test_(strings[1] == "is");
    test_(strings[2] == "going");
    test_(strings[3] == "to");
    test_(strings[4] == "make");
    test_(strings[5] == "sense");
    test_(strings[6] == "now.");
    string sentence;
    for(size_t i = 0; i < strings.size() - 1; i++)
      sentence += strings[i] += " ";
    // Manually put last word in to avoid an extra space:
    sentence += strings[strings.size() - 1];
    test_(sentence == "This is going to make sense now.");
  }
  void run() {
    parseForData();
    testData();
  }
};
#endif // RPARSE_H ///:~

//: C03:Rparse.cpp
//{L} ../TestSuite/Test
#include "Rparse.h"

int main() {
  RparseTest t;
  t.run();
  return t.report();
} ///:~

La función miembro de string rfind() vuelve por la cadena buscando elementos y reporta el indice del arreglo de las coincidencias de caracteres o string::npos si no tiene éxito.

La función miembro find_first_of( ) y find_last_of( ) pueden ser convenientemente usadas para crear una pequeña utilidad the ayude a deshechar los espacion en blanco del final e inicio de la cadena. Nótese que no se toca el string originar sino que se devuelve una nuevo string:

//: C03:Trim.h
// General tool to strip spaces from both ends.
#ifndef TRIM_H
#define TRIM_H
#include <string>
#include <cstddef>

inline std::string trim(const std::string& s) {
  if(s.length() == 0)
    return s;
  std::size_t beg = s.find_first_not_of(" \a\b\f\n\r\t\v");
  std::size_t end = s.find_last_not_of(" \a\b\f\n\r\t\v");
  if(beg == std::string::npos) // No non-spaces
    return "";
  return std::string(s, beg, end - beg + 1);
}
#endif // TRIM_H ///:~