psz_string.h

Go to the documentation of this file.

// psz_string.h (C) 2012 adolfo@di-mare.com
 
/** \file   psz_string.h
    \brief  Empaque \c (char*) para usar hileras C de forma segura en C++.
 
    Esta clase permite crear hileras C [ vectores \c (char) que terminan en \c (0) ]
    de manera segura, pues el \c (char*) está empacado dentro de una clase para que
    el destructor C++ de la clase se encargue de retornar la memoria dinámica de la
    hilera aún si se produce una excepción.
 
    Facilita mucho la programación cuando es obligatorio usar hileras C en el programa,
    como ocurre si se usan las biblitecas para leer los nombres de archivos de un
    directorio (carpeta).
 
    \author Adolfo Di Mare <adolfo@di-mare.com>
    \date   2012
*/
 
#ifndef    psz_string_h
#define    psz_string_h
 
#include  <cstring> // strlen() && memcpy()
 
/** Clase pequeñita para que no se me olvide \c delete[] para \c (char*).
    También incluye el operador de copia \c operator=() para cuando no
    es cómodo usar \c strcpy().
 
    \dontinclude string_tool_test.cpp
    \skipline    test::psz_string()
    \until       }}
*/
class psz_string {
    char * ptr; ///< Vector manejado por la clase
    // cuando ptr==0 se supone que la hilera es nula
public:
    operator char*() const { return ptr; }
    void operator=( const char* str ) {
        if ( ptr == str ) { return; } // evita auto-copia
        clear(); // assert( ptr==0 );
        if ( str!=0 ) if ( *str!=0 ) {
            unsigned N=1+strlen(str);
            ptr = new char[N];
            memcpy( ptr, str, N );
        }
    }
    void alloc( unsigned sz ) { clear(); if (sz>0) { ptr = new char[sz]; } }
    void clear() { if (ptr!=0) { delete [] ptr; } ptr=0; }
public:
    psz_string() : ptr(0) {} ///< Constructor
    psz_string( unsigned sz ) : ptr(0) { alloc(sz); }
    psz_string( const psz_string& o ) : ptr(0) { this->operator=(o.ptr); }
    psz_string( const char* str ) : ptr(0) { *this=str; }
    ~psz_string() { if (ptr!=0) { delete [] ptr; } }
    void swap( psz_string& o ) { char* tmp=o.ptr; o.ptr=ptr; ptr=tmp; }
    const char* c_str() const { return ptr; }
};
 
/**
\fn     psz_string::psz_string( unsigned sz )
\brief  Constructor que obtiene exactamente \c sz letras.
        Le cabe una hilera de hasta <code>(sz-1)</code> letras.
 
\fn     psz_string::psz_string( const psz_string& o )
\brief  Constructor de copia.
 
\fn     psz_string::psz_string( const char* str )
\brief  Constructor a partir de una hilera.
 
\fn     psz_string::clear()
\brief  Borra la hilera. Libera la memoria.
 
\fn     psz_string::~psz_string()|
\brief  Destructor: libera memoria si hace falta.
 
\fn     psz_string::alloc( unsigned sz )
\brief  Obtiene exactamente \c sz letras.
        Le cabe una hilera de hasta <code>(sz-1)</code> letras.
        Si <code>(sz==0)</code> libera la memoria.
 
\fn     psz_string::swap( psz_string& str )
\brief  Intercambia los valores \c this <==> \c str.
 
\fn     psz_string::operator=( const char* str )
\brief  Copia el valor de \c str.
 
\fn     psz_string::operator char*() const
\brief  [IMPORTANTE] Convertidor para que funcione como \c  (char*).
 
\fn     psz_string::c_str() const
\brief  Sinónimo de <code>psz_string::operator char*() const</code>
*/
 
#endif  // psz_string_h
 
// EOF: psz_string.h