Hola a todos. En esta ocasión quiero compartir un trabajo con la comunidad. También se aceptan críticas (de buena fe), sugerencias, etc ...

A veces queremos leer texto organizado en forma de tabla, con filas y columas. Por ejemplo, a partir de un fichero de texto formateado en columnas, o en el resultado de convertir una hoja de cálculo a un .txt
En tales ocasiones es común crear una matriz bidimensional de cadenas para almacenar los datos.

Como es una tarea rutinaria y repetitiva, quise desarrollar una clase "StringMatrix" de matriz de cadenas. Dicha clase posee su respectivo constructor por defecto, un constructor de copia (para obtener un objeto nuevo como copia idéntica del contenido de otro), un operador de asignación (para hacer el contenido de un StringMatrix idéntido al de otro), así como los tradicionales getElement y putElement para obtener y colocar elementos desde y en la matriz. Funcionan así:

putElement(i, j, str);

escribe el contenido del string str en la posición (i,j) de la matriz (los valores de los índices empiezan en cero). Es de hacer notar que trabaja "por copia", esto es, el elemento (i,j) reserva su espacio de memoria propio donde copia el contenido de str, luego el propio str puede alterado luego sin afectar el contenido de la matriz. Por otra parte, si se pide asignar en una posición que excede el tamaño de la matriz, se intenta dimensionar la misma previamente. Devuelve -1 en caso de error (por ejemplo, si falla la asignación de memoria), y 0 en caso de éxito.

str = getElement(i, j);

devuelve en str una copia del contenido del elemento (i,j) de la matriz. Es importante que devuelva un valor "por copia", pues así podemos alterar el string str devuelto sin afectar la matriz original.

Los métodos NRows() y NCols(), que no toman argumentos, devuelven la cantidad de filas y columnas, respectivamente, de la matriz (al crear el objeto, estos números valen cero). Por su parte, los métodos addRow() y addColumn() sirven para añadir una fila o una columna a la matriz.

Finalmente el destructor como era de esperarse libera toda la memoria dinámicamente asignada y retorna. Se cuenta con un método peculiar Reinitialize() el cual también libera la memoria asignada y pone las dimensiones de la matriz a cero. Es similar al destructor, excepto que no destruye al objeto (éste sigue vivo) sino que lo pone en las mismas condiciones de cuándo fue creado. Es como "vaciar" la matriz para poder llenarla de nuevo.

CONDICIONES DE PRECAUCIÓN: Es de hacer notar que si el objeto no se crea con éxito (falla la petición de memoria realizada), sus dimensiones se ponen en -1. Los métodos getElement() y putElement() inspeccionan primero si existe esta condición de error y en dicho caso no se ejecutan. De un modo similar los métodos addRow() y addColumn() inspecionan si la petición de memoria fue exitosa y sólo en ese caso incrementan el contador de filas o de columnas. En caso contrario, no se añade ninguna fila o columna, y las dimensiones de la matriz permanecen iguales.

En mi opinión pueden mejorarse algunas cosas, como los nombres de los métodos (quizá addCol() en lugar de addColumn()), y añadir la posibilidad de eliminar una fila o columna solamente. También incorporar un método para redimensionar, que automáticamente añada las filas o columnas que hagan falta si se pasa de una dimensión menor a una mayor, o elimine las que sobren en caso contrario.

Aquí el fichero de cabecera de la clase. Ojo: el que algunos comentarios están en inglés no significa que me lo haya copiado de internet , sino que los puse en ese idioma por si navegando por el inmenso mundo que es la web, este código llega a ser leído fuera de fronteras hispanas (jeje, aunque eso requeriría mucha suerte  )

/* SMATRIX.H
 * Declaración de la clase sMatrix
 * Las funciones miembro están definidas en smatrix.cpp 
 * 
 * Por Yoel Monsalve.
 */
 
#ifndef SMATRIX_H
#define SMATRIX_H
 
/*** Definición de la clase StringMatrix ***/
class StringMatrix {		// matriz de cadenas de caracteres
public:
	StringMatrix();			/* constructor por defecto */
	StringMatrix( StringMatrix & );		/* constructor de copia */
	~StringMatrix();			/* destructor */
	void ReInitialize(void);
	char *getElement(int, int);
	int putElement(int, int, const char *);
	int NRows();
	int NCols();
	int addRow();		/* añadir una fila: devuelve 0 si tuvo éxito, -1 si no tuvo */
	int addColumn();	/* añadir una columna: devuelve 0 si tuvo éxito, -1 si no tuvo */s	
 
	StringMatrix &operator = (StringMatrix &);
private:
	char ***Matrix;		/* para almacenar físicamente los elementos de la matriz */
	int _NRows;			/* cantidad de filas */
	int _NCols;			/* cantidad de columnas */
};
 
#endif

y ahora el código fuente de la clase:

/* SMATRIX.CPP 
 * Definiciones de funciones miembro de la clase sMatrix.
 *
 * Por Yoel Monsalve.
 */
 
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "smatrix.h"
 
/* Default constructor.
 * Constructor por defecto. */
StringMatrix :: StringMatrix( ) {
 
	Matrix = (char ***) malloc( sizeof(char **) );
 
	if (Matrix != NULL) 
		_NRows = _NCols = 0;		/* success */
	else
		_NRows = _NCols = -1;	/* constructor failed !!! */
}
 
/* Copy constructor. Creates a new object as a copy of other object. 
 * Constructor de copia. Crea un nuevo objeto como una copia de otro objeto. */
StringMatrix :: StringMatrix ( StringMatrix &S ) {
 
	int i, j;
 
	Matrix = (char ***) malloc( sizeof(char **) );
	if (Matrix != NULL) 
		_NRows = _NCols = 0;		/* success */
	else {
		_NRows = _NCols = -1;	/* constructor failed !!! */
		return;
	}
 
	/* resize at the same size of S */
	if ( S.NRows() < 0 || S.NCols() < 0 ) return;
	while ( _NRows < S.NRows() )
		addRow();
	while ( _NCols < S.NCols() )
		addColumn();
 
	printf("%d, %d\n", S.NRows(), S.NCols());
	/* and copy here the content of S */
	for ( i = 0; i < _NRows; i++ )
		for ( j = 0; j < _NCols; j++ )
			Matrix[i][j] = S.getElement(i, j);
}
 
/* Assignment operator, from other StringMatrix object.
 * Operador de asignacióm, a partir de otro objeto StringMatrix. */
StringMatrix & StringMatrix :: operator = (StringMatrix &S) {
 
	int i, j;
 
	/* avoid self-assignment */
	if ( &S == this ) return *this;
 
	/* caution if matrix creation failed */
	if ( _NRows < 0 || _NCols < 0 )
		return *this;
 
	/* resize at the same size of S */
	if ( S.NRows() < 0 || S.NCols() < 0 ) return *this;
	while ( _NRows < S.NRows() )
		addRow();
	while ( _NCols < S.NCols() )
		addColumn();
 
	/* and copy here the content of S */
	for ( i = 0; i < _NRows; i++ )
		for ( j = 0; j < _NCols; j++ )
			Matrix[i][j] = S.getElement(i, j);
}
 
/* "Re-initializes" the object. Frees the dinamic allocated memory, and
 * it puts the dimensions to zero. This is, returns he object to the original
 * state like it was created.
 *
 * "Re-inicializa" el objeto. Libera la memoria dinámicamente asignada,
 * y pone las dimensiones a cero. Es decir, devuelve el objeto al estado
 * original como fue creado */
void StringMatrix :: ReInitialize( ) {
 
	int i, j;
 
	/* if matrix creation failed, try create it again */
	if ( _NRows < 0 || _NCols < 0 ) {
		Matrix = (char ***) malloc( sizeof(char **) );
		if (Matrix != NULL) 
			_NRows = _NCols = 0;	/* success */
		else {
			_NRows = _NCols = -1;	/* constructor failed !!! */
			return;
		}
	}
 
	/* frees the allocated memory space */
	if (_NRows > 0) {
		for (i = 0; i < _NRows; i++) {
			if (_NCols > 0) {
				for (j = 0; j < _NCols-1; j++)
					free(Matrix[i][j]); 
					Matrix[i][j] = NULL;
			}
			free(Matrix[i]);
			Matrix[i] = NULL;
		}
	}
	_NRows = _NCols = 0;
}
 
/* Class destructor /
 * Destructor de la clase */
StringMatrix :: ~StringMatrix( ) {
	int i, j;
 
	/* frees the allocated memory assigned to the objects /
	 * libera el espacio de memoria asignado a los objetos */
	for (i=0; i<_NRows; i++) {
		for (j=0; j<_NCols; j++) {
			free( Matrix[i][j] ); 
			Matrix[i][j] = NULL;
		}
		free( Matrix[i] );
		Matrix[i] = NULL;
	}
	free( Matrix );
	Matrix = NULL;
 
	_NRows = -1;
	_NCols = -1;
}
 
/* Get the number of rows of the matriz /
 * Obtener el numero de filas de la matriz */
int StringMatrix :: NRows( ) { 
 
	return _NRows; 
}
 
/* Get the number of columns of the matriz /
 * Obtener el numero de columnas de la matriz */
int StringMatrix :: NCols( ) { 
 
	return _NCols; 
}
 
/* Get an specific element in the matrix. Warning: the indexes start in zero.
 * On success is returned a copy of the string stored in such element of
 * the matrix. On error, returns NULL.
 
/* Obtener un elemento especifico de la matriz. Cuidado: los índices empiezan
 * en cero. En caso exitoso devuelve una copia de la cadena almacenada en
 * dicho elemento de la matriz. En caso de error, devuelve NULL. */
char * StringMatrix :: getElement( int i, int j ) {
 
	char *s;
 
	/* caution if matrix creation failed */
	if ( _NRows < 0 || _NCols < 0 )
		return NULL;
 
	/* must be 0 <= i <= _N_Rows - 1, and 0 <= j <= _NCols - 1 */
	if (i < 0 || i >= _NRows || j < 0 || j >= _NCols) 
		return NULL;
 
	if ( ( s = (char *) malloc ( (strlen(Matrix[i][j]) + 1) * sizeof(char) ) ) == NULL )
		return NULL;
 
	strcpy(s, Matrix[i][j]);
	return s;
}
 
/* Puts an element in a specified position of the matrix. If the position
 * exceed the size of matrix, the same is automatically resized.
 * On success returns 0, and -1 otherwise.
 *
 * Pone un elemento en una posicion especificada de la matriz. Si la posicion
 * excede el tamano de la matriz, la misma es redimensionada automaticamente.
 * Devuelve 0 si tuvo exito, -1 si no tuvo. */
int StringMatrix :: putElement( int i, int j, const char * s ) {
 
	char *cPtr;
 
	/* caution if matrix creation failed */
	if ( _NRows < 0 || _NCols < 0 )
		return -1;
 
	/* fail if i < 0, or j < 0 */
	if ( i < 0 | j < 0 )	
		return -1;	
 
	/* if i > _NRows - 1, completed rows that are needed */
	while ( i >= _NRows )
		addRow();
 
	/* if j > _NCols - 1, completed columns that are needed */
	while ( j >= _NCols )
		addColumn();
 
	/* now, copies the s string in the (i,j) element of the matrix (allocates 
	 * memory before) */
	if ( ( cPtr = (char *) realloc( Matrix[i][j], (strlen(s) + 1) * sizeof(char) ) ) != NULL ) { 
		strcpy(cPtr, s);
		Matrix[i][j] = cPtr;
		return 0;
	}
	else
		return -1;
 
}
 
/* Add a row to the matrix. On success returs 0, and -1 otherwise. 
 *
 * Anade una fila a la matriz. Devuelve 0 si tuvo éxito, -1 si no tuvo. */
int StringMatrix :: addRow() {
 
	char ***xPtr;
	char **yPtr;
	char *zPtr;
	int j;
 
	/* caution if matrix creation was failed */
	if ( _NRows < 0 ) return -1;
 
	/* allocate memory for one more row */	
	if ( ( xPtr = (char ***) realloc( Matrix, (_NRows + 1) * sizeof(char **) ) ) != NULL ) {
		Matrix = xPtr;
 
		/* if matrix already has columns added */
		if ( _NCols > 0 ) {
			/* complete the new row with empty elements */
			if ( ( yPtr = (char **) malloc( _NCols * sizeof(char *) ) ) != NULL ) {
				Matrix[_NRows] = yPtr;
				for (j = 0; j < _NCols; j++) {
					if ( ( zPtr = (char *) malloc( sizeof(char) ) ) != NULL ) {
						Matrix[_NRows][j] = zPtr;
						*zPtr = '\0';
					}
					else
						return -1;
				}
			}
			else
				return -1;
		}
		/* otherwise */
		else {
			/* complete the new row with empty elements */
			if ( ( yPtr = (char **) malloc( 1 * sizeof(char *) ) ) != NULL ) {
				Matrix[_NRows] = yPtr;
				if ( ( zPtr = (char *) malloc( sizeof(char) ) ) != NULL ) {
					Matrix[_NRows][0] = zPtr;
					*zPtr = '\0';
				}
				else
					return -1;
			}
			else
				return -1;
		}
	}
	else 
		return -1;
 
	/* Success, then increase _NRows and return. */
	_NRows++;
	return 0;
}
 
/* Add a column to the matrix. On success returs 0, and -1 otherwise. 
 *
/* Anade una columna a la matriz. Devuelve 0 si tuvo éxito, -1 si no tuvo. */
int StringMatrix :: addColumn() {
 
	char **yPtr;
	char *zPtr;
	int i;
 
	/* return if matrix creation was failed */
	if (_NRows <= 0 || _NCols < 0) return -1;
 
	for (i = 0; i < _NRows; i++) {
		/* allocate memory for one more column */
		if ((yPtr = (char **) realloc( Matrix[i], (_NCols + 1) * sizeof(char *) ) ) != NULL ) {
			Matrix[i] = yPtr;
			if ( ( zPtr = (char *) malloc( sizeof(char) ) ) != NULL ) {
				Matrix[i][_NCols] = zPtr;
				*zPtr = '\0';
			}
			else
				return -1;
		}
		else
			return -1;
	}
 
	/* Success, then increase _NCols and return. */
	_NCols++;
	return 0;
}

Podemos ver ahora su funcionamiento, en el sencillo archivo de prueba que crea dos matrices, llena una con cuatro cadenas. Luego, en la segunda matriz se copia el contenido de la primera, y éste se imprime por la pantalla ¡Fácil!

#include <stdio.h>
#include <smatrix.h>       /* fichero de cabecera de la clase */
 
int main() {
 
	StringMatrix S, M;
	int i, j;
 
	S.putElement(0, 0, "hugo");
	S.putElement(0, 1, "paco");
	S.putElement(1, 0, "maria");
	S.putElement(1, 1, "luisa");
 
	/* copia contenido de S en M */
	M = S;
	/* y lo imprime en pantalla */
	for (i = 0; i < 2; i++) {
		for (j = 0; j < 2; j++)
			printf("%s\t", M.getElement(i, j) );
		fputs("\n", stdout);
	}
 
	return 0;
}

NOTA: para compilar el fichero de prueba, llamado por ejemplo test.cpp, enlazado con el fichero smatrix.cpp que define la clase StringMatrix, usar la orden:

g++ -o test test.cpp smatrix.cpp

y suponiendo que los tres archivos test.cpp, smatrix.cpp y smatrix.h están en el mismo directorio. Para un proyecto grande valdría la pena crear directorios src, include, lib donde poner los ficheros apropiados y compilar adecuadamente según el caso. Se puede también hacer una biblioteca con esta y otras clases de utilería, ustedes ya saben ...

Sugerencias, comentarios ?????

Bueno eferion, aquí la respuesta es cuestión de gustos. Ambas soluciones son funcionales, por supuesto que usando plantillas STL el código es más breve y fácil para el programador, pero por otra parte hay cierta "sobrecarga", al invocar reiterativamente otras clases y sus métodos.

Claro que las clases STL están optimizadas para aumentar la velocidad de ejecución, pero mi intención aquí fue proponer una clase de matrices que usara sólo los más métodos más básicos, y sin invocar a otras clases. Pero al fin ahora tenemos dos enfoques diferentes para el mismo problema ...

Totalmente de acuerdo, y con respecto a " lagunas de memoria, accesos a memoria no reservada o desbordamientos de buffer", te cuento que sí que tuve muchos dolores de cabeza con eso, pues me ocurría en las primeras versiones del código.

La verdad, este fue un ejercicio más que todo para aprender, pues como dices en una aplicación real lo más lógico es usar STL pues se vuelve más fácil de comprender y mantener.

Hacía tiempo quise ponerme a "inventar", y emular clases con C pero me encontré algunos problemas. Por ejemplo, tengamos la clase circle (círculo) con sus miembros x, y, radious, cuyos significados son obvios. Ahora queremos definir el método setX para cambiar el valor del miembro x. Claro, no son clases verdaderas, sino la emulación de éstas en C.

En C++ las clases mantienen su espacio privado de nombres de métodos, por lo que debemos usar el operador :: para acceder a ellos. No sucede lo mismo en C, donde hay que usar funciones "sueltas". Una idea sería prefijar los nombres de los métodos con el nombre de la clase, algo como:

CIRCLE_setX( double new_x, circle * this)

aunque aún es un poco burdo. No se si es lo mejor que se puede hacer a costa de mantenerse puro dentro de C, o se puede mejorar un poquito.
¿Acaso podemos ser creativos e inventar algo con #define para volverlo más amigable?

A ver, ¿cómo hacían los programadores antiguos, cuando no había aparecido C++?