Hola. ¿Qué simbolos dibujan esos códigos ASCII? A mí no me parecen símbolos de un tablero de ajedrez o similar ...  

No se si querrás producir algo como esto:

+---+---+---+---+
| a | b | c | d |
+---+---+---+---+
| e | f | g | h |
+---+---+---+---+


Bueno, esperando a que respondas pero si ese es el caso aquí tienes un pequeño código que hace la tarea. Por comodida, creé la función fillRow que rellena una fila dada de la matriz con los caracteres de una cadena pasada como argumento. En este caso puse 'x' como relleno de la casilla, y espacio para dejar vacía la misma. Reemplaza el símbolo de relleno por el que tú requieres. Además, puedes cambiar las constantes M y N por otros valores en caso de querer redimensionar la matriz.

#include <stdlib.h>
#include <stdio.h>
 
#define M 8
#define N 8
 
void fillRow( char **, int, const char *);
void printBoard( char ** );
 
int main() {
 
	char **A;
	int i;
 
	/* Inicializa la matriz, y termina si ocurre error */
	if ( ( A = (char **) malloc ( M * sizeof(char *) ) ) == NULL )
		return -1;
	for (i = 0; i < M; i++ )
		if ( ( A[i] = (char *) malloc ( N * sizeof(char) ) ) == NULL )
			return -1;
 
	fillRow( A, 0, "xxx xx x" );
	fillRow( A, 1, "x  x  x " );
	fillRow( A, 2, "x x x x " );
	fillRow( A, 3, "xxxxx   " );
	fillRow( A, 4, "xx      " );
	fillRow( A, 5, "xx xx xx" );
	fillRow( A, 6, "x  xxxx " );
	fillRow( A, 7, "xxxxxxxx" );
 
	/* imprimir el tablero */
	printBoard( (char **)A ); 
 
	return 0;
}
 
/* Rellena la fila i de la matriz A con los elementos del vector x */
void fillRow( char **A, int i, const char *x) {
 
	int j;
 
	for (j = 0; j < N; j++)
		A[i][j] = x[j];
}
 
/* Imprime un tablero de 8x8, rellenando las casillas con los 
 * caracteres almacenados en la matriz A
 */
void printBoard( char **A ) {
 
	int i, j;
	char c, *s;
 
	puts("+---+---+---+---+---+---+---+---+");
	for (i = 0; i < M; i++) {
		putchar('|');
		for (j = 0; j < N; j++)
			if ( A[i][j] != '\0' )
				printf(" %c |", A[i][j]);
			else
				printf("   |");
		puts("\n+---+---+---+---+---+---+---+---+");
	}
	putchar('\n');
}

Estimados engelx y leosansan,

Me acuso culpable de tener problemas de visión al no haber leído la palabra "centenar". A cualquiera le ocurre un lapsus de lectura, y esto no es motivo para descalificar la preparación de la persona. La solución que propuse es correcta de no ser por la condición i + j + k = 100 que sinceramente no había leído. ¡Sencillamente eso!

Y me parece que ustedes han exagerado este caso con el único motivo de descalificarme. Si me quieren fuera del foro, pues díganmelo, o dirijan una petición al moderador sustentada con los delitos de que me acusan.

El programa se corrige al añadir la condición i + j + k == 100 dentro del if y ajustar los valores de i_MAX, j_MAX y k_MAX para que no excedan de 98.

Respecto al código complejo, pues traté de hacer un programa un poco elaborado, que "hablara" con el usuario y fuera flexible en el sentido de que las constantes A, B, C, T pudieran ser cambiadas para resolver un problema con valores diferentes. Me acuso también culpable de estos delitos!!! Ah, ..... y la línea

printf("%d, %d, %d, %d\n", i_MAX, j_MAX, k_MAX, i_MAX*j_MAX*k_MAX);

no iba, era sólo con propósitos de debug 

En esta ocasión quiero compartir un programita divertido que muestra de manera interactiva la ejecución del algoritmo de ordenamiento por inserción. Básicamente va ordenando el arreglo e indicando por pantalla lo que va haciendo: cómo se mueven los elementos y cómo va quedando el vector tras cada paso ....

Un programita amigable y con un propósito bien didáctivo .... enjoy it!!

 #include <stdio.h>
 #include <stdlib.h>
 
 #define N 5
 
 int main(void) {
 
	int x[N] = {7, 3, 11, 5, 1};
	int i, j, k;
	int aux;
 
	printf("Arreglo original: \n");			
	for (k = 0; k < N; k++)
		printf(" %d", x[k]);
	printf("\n");
 
	for (i = 1; i < N; i++) {
 
		/* buscamos desde 0 hasta i - 1, el primer elemento que sea 
		 * mayor que x[i] */
		printf("ubicando %d ...", x[i]);
		j = 0;
		while (j < i && x[j] <= x[i])
			j++;
 
		if ( j < i ) {
 
			/* insertar x[i] en la posición j, y desplazar los
			 * restantes elementos hacia la derecha */
			printf(" poner en posicion %d\n", j);
 
			for (k = 0; k < N; k++)
				printf(" %d", x[k]);
			printf("  -> ");
 
			aux = x[i];
			for (k = i; k > j; k--)
				x[k] = x[k-1];
			x[j] = aux;
 
			for (k = 0; k < N; k++)
				printf(" %d", x[k]);
			printf("\n");	
		}
		else
			printf(" sin cambios\n");
	}
	printf("El arreglo final ordenado es:\n");
	for (i = 0; i < N; i++)
		printf(" %d", x[i]);
	printf("\n");
 
	return 0;
 }

Para ayudarte mejor creo que debes darnos más información sobre el contexto de tu trabajo. Pareciera que quisieras ordenar un arreglo de cadenas, .... ahora no le veo sentido a guardar los resultados de las permutaciones.

Ten en cuenta que el número de permutaciones puede ser mayor a la cantidad de elementos del arreglo, o sea que no sabrás de antemano cuántas cadenas intermedias debes guardas. Quizá se requiera dimensionamiento dinámico (aumento de la longitud del vector en tiempo de ejecución).

Por otra parte, si tratas de implementar un algoritmo de ordenamiento, ¿por qué la permutación de los elementos se realiza incondicionalmente, es decir, sin verificar ninguna condición de orden entre los elementos?

Debes aclararnos mejor sobre el trabajo que se quiere realizar ...

Saludos a todos. Como profesor de matemáticas me permito hacer algunos comentarios. Es básicamente un problema lógico de combinatoria. Pero quiero decir que el planteamiento de suponer un máximo de 100 asistentes hombres no es técnicamente correcto (empezando porque es un completamente arbitrario). Además, hay que tener en cuenta que elegido un valor para la cantidad de hombres, aún existen muchos pares de combinaciones de mujer-niño. O sea, se tienen tres variables i, j, k y no una.

En síntesis, el problema consiste en encontrar todas las tripletas de valores i, j, k que satisfagan:

A*i + B*j + C*k = T

siendo A, B, C la cantidad de monedas aportadas por cada hombre, mujer o niño respectivamente, T el total de monedas, y siendo i, j, k enteros positivos.
Y efectivamente hay infinitas soluciones, por tratarse de más incógnitas que ecuaciones!!!

Yo voy a suponer (no se si esto se halle efectivamente entre las condiciones del ejercicio) que hubo por lo menos uno hombre, por lo menos una mujer y por lo menos un niño, así que i, j, k deben ser mayores o iguales a 1.

Ahora, ¿cuáles son los mayores valores posibles de i, de j  y de k? Pues, el máximo de i viene dado cuando j  y k tienen los valores mínimos: j = k = 1 (una sola mujer y un solo niño). Ello produce:

i_MAX = (T - 1*B - 1*C)/A;

(redondeando i_MAX al entero más cercano por debajo). Similarmente se obtienen el máximo de j y el máximo de k:

j_MAX = (T - 1*A - 1*C)/B;
k_MAX = (T - 1*A - 1*B)/C;


Sacando las cuentas se obtiene un máximo de:

103 hombres
78 mujeres
192 niños

Luego debemos probar todas las combinaciones para 1 <= i <= i_MAX, 1 <= j <= j_MAX, 1 <= k <= k_MAX, y seleccionar aquéllas donde  A*i + B*j + C*k == T. Ahora sabiendo todo esto,el código del programa resulta bien sencillo, pero les cuento que se hallan 106 soluciones, jeje. La que se propuso H = 33, M = 46, N = 21 es una de ellas pero hay otras por ejemplo:

H = 25, M = 46, N = 36
H = 26, M = 21, N = 96
H = 27, M = 36, N = 57

y muchas más.

El programa aquí:

#include <stdlib.h>
#include <stdio.h>
 
/* Nota: Sean
 *
 *  A la cantidad de monedas que aporta cada hombre
 *  B la cantidad de monedas que aporta cada mujer
 *  C la cantidad de monedas que aporta cada nino
 *  T el total de monedas
 *
 * entones tenemos:
 */
#define A 75
#define B 99
#define C 40
#define T 7869
/* por otra parte, siendo i la cantidad de hombres, j la cantidad
 * de mujeres y k la cantidad de ninos, la condicion buscada es que
 *  
 *  A*i + B*j + C*k = T
 *
 * siendo i, j, k numeros enteros y positivos. La solucion la buscaremos
 * por tanteo (fuerza bruta) mostrando todas las combinaciones posibles.
 */
 
int main () {
 
	int i, j, k, count;
	int i_MAX, j_MAX, k_MAX;
 
	printf( "********************************************\n"
		    "Programa de calculo de combinaciones\n"
		    "********************************************\n\n" );
 
	printf( "Condiciones:\n"
			" cada hombre aporta %d monedas\n"
			" cada mujer aporta  %d monedas\n"
			" cada nino aporta   %d monedas\n" 
			" Total:             %d monedas.\n\n",
			A, B, C, T );
 
	/* El maximo valor posible de i sera el cociente entero de 
	 * (T - 1*B - 1*C) entre A, es decir, el valor entero de i que satisface
	 * la ecuacion:
	 * 
	 *  A*i + B*j + C*k = T
	 *
	 * con los valores minimos de j = 1, k = 1. De modo similar se calculan
	 * los valores maximos posibles de j y k.
	 */
	i_MAX = (T - 1*B - 1*C)/A;
	j_MAX = (T - 1*A - 1*C)/B;
	k_MAX = (T - 1*A - 1*B)/C;
 
	printf("%d, %d, %d, %d\n", i_MAX, j_MAX, k_MAX, i_MAX*j_MAX*k_MAX);
 
	count = 0;
	for ( i = 1; i <= i_MAX; i++ ) 
		for ( j = 1; j <= j_MAX; j++ )
			for ( k = 1; k <= k_MAX; k++ )
				if ( A*i + B*j + C*k == T ) {
					printf( "Se encontro la combinacion H = %d, M = %d, N = %d\n", 
						i, j, k);
					count ++;
				}
	printf( "%d resultados. -- FIN DEL PROGRAMA --\n", count);		
}

y el resultado que arroja (larguísimo):

********************************************
Programa de calculo de combinaciones
********************************************

Condiciones:
 cada hombre aporta 75 monedas
 cada mujer aporta  99 monedas
 cada nino aporta   40 monedas
 Total:             7869 monedas.

Se encontro la combinacion H = 1, M = 6, N = 180
Se encontro la combinacion H = 1, M = 46, N = 81
Se encontro la combinacion H = 2, M = 21, N = 141
Se encontro la combinacion H = 2, M = 61, N = 42
Se encontro la combinacion H = 3, M = 36, N = 102
Se encontro la combinacion H = 3, M = 76, N = 3
Se encontro la combinacion H = 4, M = 11, N = 162
Se encontro la combinacion H = 4, M = 51, N = 63
Se encontro la combinacion H = 5, M = 26, N = 123
Se encontro la combinacion H = 5, M = 66, N = 24
Se encontro la combinacion H = 6, M = 1, N = 183
Se encontro la combinacion H = 6, M = 41, N = 84
Se encontro la combinacion H = 7, M = 16, N = 144
Se encontro la combinacion H = 7, M = 56, N = 45
Se encontro la combinacion H = 8, M = 31, N = 105
Se encontro la combinacion H = 8, M = 71, N = 6
Se encontro la combinacion H = 9, M = 6, N = 165
Se encontro la combinacion H = 9, M = 46, N = 66
Se encontro la combinacion H = 10, M = 21, N = 126
Se encontro la combinacion H = 10, M = 61, N = 27
Se encontro la combinacion H = 11, M = 36, N = 87
Se encontro la combinacion H = 12, M = 11, N = 147
Se encontro la combinacion H = 12, M = 51, N = 48
Se encontro la combinacion H = 13, M = 26, N = 108
Se encontro la combinacion H = 13, M = 66, N = 9
Se encontro la combinacion H = 14, M = 1, N = 168
Se encontro la combinacion H = 14, M = 41, N = 69
Se encontro la combinacion H = 15, M = 16, N = 129
Se encontro la combinacion H = 15, M = 56, N = 30
Se encontro la combinacion H = 16, M = 31, N = 90
Se encontro la combinacion H = 17, M = 6, N = 150
Se encontro la combinacion H = 17, M = 46, N = 51
Se encontro la combinacion H = 18, M = 21, N = 111
Se encontro la combinacion H = 18, M = 61, N = 12
Se encontro la combinacion H = 19, M = 36, N = 72
Se encontro la combinacion H = 20, M = 11, N = 132
Se encontro la combinacion H = 20, M = 51, N = 33
Se encontro la combinacion H = 21, M = 26, N = 93
Se encontro la combinacion H = 22, M = 1, N = 153
Se encontro la combinacion H = 22, M = 41, N = 54
Se encontro la combinacion H = 23, M = 16, N = 114
Se encontro la combinacion H = 23, M = 56, N = 15
Se encontro la combinacion H = 24, M = 31, N = 75
Se encontro la combinacion H = 25, M = 6, N = 135
Se encontro la combinacion H = 25, M = 46, N = 36
Se encontro la combinacion H = 26, M = 21, N = 96
Se encontro la combinacion H = 27, M = 36, N = 57
Se encontro la combinacion H = 28, M = 11, N = 117
Se encontro la combinacion H = 28, M = 51, N = 18
Se encontro la combinacion H = 29, M = 26, N = 78
Se encontro la combinacion H = 30, M = 1, N = 138
Se encontro la combinacion H = 30, M = 41, N = 39
Se encontro la combinacion H = 31, M = 16, N = 99
Se encontro la combinacion H = 32, M = 31, N = 60
Se encontro la combinacion H = 33, M = 6, N = 120
Se encontro la combinacion H = 33, M = 46, N = 21
Se encontro la combinacion H = 34, M = 21, N = 81
Se encontro la combinacion H = 35, M = 36, N = 42
Se encontro la combinacion H = 36, M = 11, N = 102
Se encontro la combinacion H = 36, M = 51, N = 3
Se encontro la combinacion H = 37, M = 26, N = 63
Se encontro la combinacion H = 38, M = 1, N = 123
Se encontro la combinacion H = 38, M = 41, N = 24
Se encontro la combinacion H = 39, M = 16, N = 84
Se encontro la combinacion H = 40, M = 31, N = 45
Se encontro la combinacion H = 41, M = 6, N = 105
Se encontro la combinacion H = 41, M = 46, N = 6
Se encontro la combinacion H = 42, M = 21, N = 66
Se encontro la combinacion H = 43, M = 36, N = 27
Se encontro la combinacion H = 44, M = 11, N = 87
Se encontro la combinacion H = 45, M = 26, N = 48
Se encontro la combinacion H = 46, M = 1, N = 108
Se encontro la combinacion H = 46, M = 41, N = 9
Se encontro la combinacion H = 47, M = 16, N = 69
Se encontro la combinacion H = 48, M = 31, N = 30
Se encontro la combinacion H = 49, M = 6, N = 90
Se encontro la combinacion H = 50, M = 21, N = 51
Se encontro la combinacion H = 51, M = 36, N = 12
Se encontro la combinacion H = 52, M = 11, N = 72
Se encontro la combinacion H = 53, M = 26, N = 33
Se encontro la combinacion H = 54, M = 1, N = 93
Se encontro la combinacion H = 55, M = 16, N = 54
Se encontro la combinacion H = 56, M = 31, N = 15
Se encontro la combinacion H = 57, M = 6, N = 75
Se encontro la combinacion H = 58, M = 21, N = 36
Se encontro la combinacion H = 60, M = 11, N = 57
Se encontro la combinacion H = 61, M = 26, N = 18
Se encontro la combinacion H = 62, M = 1, N = 78
Se encontro la combinacion H = 63, M = 16, N = 39
Se encontro la combinacion H = 65, M = 6, N = 60
Se encontro la combinacion H = 66, M = 21, N = 21
Se encontro la combinacion H = 68, M = 11, N = 42
Se encontro la combinacion H = 69, M = 26, N = 3
Se encontro la combinacion H = 70, M = 1, N = 63
Se encontro la combinacion H = 71, M = 16, N = 24
Se encontro la combinacion H = 73, M = 6, N = 45
Se encontro la combinacion H = 74, M = 21, N = 6
Se encontro la combinacion H = 76, M = 11, N = 27
Se encontro la combinacion H = 78, M = 1, N = 48
Se encontro la combinacion H = 79, M = 16, N = 9
Se encontro la combinacion H = 81, M = 6, N = 30
Se encontro la combinacion H = 84, M = 11, N = 12
Se encontro la combinacion H = 86, M = 1, N = 33
Se encontro la combinacion H = 89, M = 6, N = 15
Se encontro la combinacion H = 94, M = 1, N = 18
Se encontro la combinacion H = 102, M = 1, N = 3
106 resultados. -- FIN DEL PROGRAMA --

 

A veces cuando colocamos fragmentos de código muy grandes en nuestros posts, los mismos se hacen de una extensión inmensa. Imagínense si se trata de un proyecto grande con varias cabecera, y fuentes ...

Me gustaría saber si ustedes recomienda un sitio externo especializado en subir archivos fuentes de C, y colocar en nuestros post sólo el link a dichos sitios

.......... 

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 ?????

Es justo lo que había supuesto, un lapsus involuntario ... (también me ha sucedido). No problem!!!

Bueno, comentando acerca del free ha debido ser un despiste o lapsus de eferion, pues si desasignas la memoria del arreglo, el mismo ya no será útil  

Ahora ya no hablando del programa de eferion sino más en general. Sabemos que sobre gustos no hay nada escrito, pero si se permite mi opinión siempre me ha parecido más elegante la solución de pasar parámetros por referencia a la función. De ese modo se pueden realizar modificaciones a los mismos, con el mismo efecto como si la función devolviera varios parámetros de retorno (que no es permitido en C).

Incluso si usaras un estructura, puede pasarse la misma como argumento por referencia de la función, en lugar de devolver la estructura como valor de retorno.

La razón por la que me inclino por esta modalidad es que (y repito es una opinión personal) luce más acorde con la filosofía original de diseño de C. A ver, por ejemplo cuando usas la función estándar fread para leer de un fichero, no obtienes el arreglo de bytes leídos como valor de retorno, ¿verdad? En su lugar, dicho arreglo (un puntero a char) es pasado como argumento de entrada.

El valor de retorno de las funciones debería ser utilizado más bien para indicar si hubo un error en la ejecución de la misma (devuelve -1) o ejecución exitosa (devuelve 0). O en el caso de funciones de E/S como fread para indicar la cantidad de elementos leídos.

Saludos

Jeje, bueno yo no se por qué el autor del post usó una estructura (aunque sinceramente me pareció algo complicado), sólo traté de aclarar la duda planteada respetando hasta lo posible la integridad del tema original