barajar filas de un array multidimensional

[aguml]

Hola amigos, esto es C pero no sabia donde ponerlo.
El caso es que estoy intentando crearme un pequeño codigo al que le diga el numero de columnas y filas y las palabras a colocar y que me cree una sopa de letras con ellas. El codigo lo encontre por internet pero no usaba memoria dinamica asi que lo he modificado y antes de modificarlo iba bien pero ahora me da errores al intentar añadir las palabras y al intentar rellenar la sopa de letras y estoy seguro de que estoy haciendo algo mal al trabajar con los punteros de la memoria que he obtenido pero no se que. ¿pueden ayudarme?
Este es el codigo:
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>

#define LARGOMAX 21

// Llena la matriz con caracteres /0
void inicializa(char **m, int filas, int columnas) {
int i, j;

for (i = 0; i < filas; i++)
for (j = 0; j < columnas; j++)
m[i][j] = '\0';
}

void PedirPalabras(char **palabras, int nPalabras){
int i,x;

for (i = 0; i < nPalabras; i++){
printf("Introduce una palabra: ");
scanf("%s", palabras[i]);
for (x = 0; x < LARGOMAX; x++){
palabras[i][x]=toupper(palabras[i][x]);
}
}
}

// Llena los espacios vacíos con caracteres al azar
void rellena(char **m, int filas, int columnas) {
int i, j;

for (i = 0; i < filas; i++)
for (j = 0; j < columnas; j++)
if (m[i][j] == '\0')
m[i][j] = rand() % 26 + 65;
}

// Muestra la sopa de letras
void muestra(char **m, int filas, int columnas) {
int i, j;

printf("\n\n");
for (i = 0; i < filas; i++) {
for (j = 0; j < columnas; j++)
printf("%c ", m[i][j]);
printf("\n");
}
}

// Valida que la palabra s se pueda agregar a la matriz m
// en la posición (x, y) y en la dirección (dx, dy)
int valida(char **m, int filas, int columnas, const char *s, int x, int y, int dx, int dy) {
int i, v = 1;

for (i = 0; i < (int)strlen(s); i++, x += dx, y += dy){
if (x < 0 || y < 0 || x >= columnas || y >= filas || (m[y][x] != s[i] && m[y][x] != '\0')){
v = 0;
break;
}
}
if(v==1)
printf("\n%s puede agregarse (x%d, y%d, dx%d, dy%d): %d", s, x, y, dx, dy, v);

return v;
}

// Agrega la palabra s a la sopa de letras
void agrega(char **m, int filas, int columnas, const char *s) {
int i, x, y, dx, dy;

dx = rand() % 3 - 1;
dy = rand() % 3 - 1;
dx = dx == 0 ? 1 : dx;
while (!valida(m, filas, columnas, s, x = rand() % columnas, y = rand() % filas, dx, dy)) ;
for (i = 0; i < (int)strlen(s); i++, x += dx, y += dy)
m[y][x] = s[i];
}

int main() {
// Las palabras que se van a agregar a la sopa de letras
// Deben ser tantas palabras como la definción de PAL
// Escritas en mayúsculas para que se vean bien
char **m, **palabras;
int i;
int filas, columnas, nPalabras;
srand(time(0));

printf("Introduce el numero de caracteres horizontales: ");
scanf("%d",&columnas);
printf("Introduce el numero de caracteres verticales: ");
scanf("%d",&filas);

//Obtengo la memoria suficiente para el array que contendrá la sopa de letras
if (( m = malloc( filas*sizeof( char* ))) == NULL )
{
/* error */
}else{

for ( i = 0; i < filas; i++ )
{
if (( m[i] = malloc( columnas )) == NULL )
{
/* error */
}else{
//Obtengo la memoria suficiente para el array que contendrá las palabras a colocar en sopa de letras
printf("Introduce el numero de palabras a colocar: ");
scanf("%d",&nPalabras);

if (( palabras = malloc( nPalabras*sizeof( char* ))) == NULL )
{
/* error */
}else{
for ( i = 0; i < nPalabras; i++ )
{
if (( palabras[i] = malloc( LARGOMAX )) == NULL )
{
/* error */
}else{
//Obtengo las palabras y las almaceno en el array
PedirPalabras(palabras, nPalabras);

//Lleno la sopa de letra con \0's
inicializa(m,filas,columnas);

//Coloco las palabras en la sopa de letra
for (i = 0; i < nPalabras; i++)
agrega(m, filas, columnas, palabras[i]);

//Muestro como quedan las palabras
muestra(m, filas, columnas);
getchar();

//Relleno los huecos de la sopa de letra
rellena(m, filas, columnas);
getchar();

//Muestro como queda la sopa de letra
muestra(m, filas, columnas);
getchar();
}
}
}
}
}
}

//Libero la memoria de la matriz de la sopa de letras
if( m != NULL ){
for ( i = 0; i < filas; i++ )
{
if (m[i] != NULL)
{
free(m[i]);
}
}
}
free(m);

//Libero la memoria de la matriz de las palabras
if( palabras != NULL ){
for ( i = 0; i < nPalabras; i++ )
{
if (palabras[i] != NULL)
{
free(palabras[i]);
}
}
}
free(palabras);
return 0;
}

[Casimiro Notevi]

... lo he modificado y antes de modificarlo iba bien pero ahora me da errores
¿Qué errores?
No estaría mal que pusieras el código original también.

[aguml]

Lo saque de aqui pero vamos que lo que hice fue cambiar por memoria dinamica los arrais y permitir decidir al usuario el tamaño de la sopa de letras, el numero de palabras a colocar, y cuales serán esas palabras y de paso quité alguna variable global:
¿Como crear una sopa de letras en C? | Yahoo Respuestas (https://es.answers.yahoo.com/question/index?qid=20101125210655AAmzl4Z)

[Casimiro Notevi]

Vale, pero ¿qué error tiene y dónde?

[aguml]

Vale, pero ¿qué error tiene y dónde?
Pues de momento si pongo que la sopa será de 8x8 y que colocaré 3 palabras, al meter la tercera palabra crashea y si no lo hace lo hace al inicializar con \0 la sopa. Son fallos seguro porque no estoy haciendo algo bien con el tema de punteros o con la memoria dinamica.

[escafandra]

En tu bucle principal pides palabras sin haber seresvado el espacio para todas elles y "peta"

Mira esta modificación a tu código respetando más o menos su estructura:


#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>

#define LARGOMAX 21

// Llena la matriz con caracteres /0
void inicializa(char **m, int filas, int columnas) {
int i, j;

for (i = 0; i < filas; i++)
for (j = 0; j < columnas; j++)
m[i][j] = '\0';
}

void PedirPalabras(char **palabras, int nPalabras){
int i,x;

for (i = 0; i < nPalabras; i++){
printf("Introduce una palabra: ");
scanf("%s", palabras[i]);
for (x = 0; x < strlen(palabras[i]); x++){
palabras[i][x]=toupper(palabras[i][x]);
}
}
}

// Llena los espacios vacíos con caracteres al azar
void rellena(char **m, int filas, int columnas) {
int i, j;

for (i = 0; i < filas; i++)
for (j = 0; j < columnas; j++)
if (m[i][j] == '\0')
m[i][j] = rand() % 26 + 65;
}

// Muestra la sopa de letras
void muestra(char **m, int filas, int columnas) {
int i, j;

printf("\n\n");
for (i = 0; i < filas; i++) {
for (j = 0; j < columnas; j++)
printf("%c ", m[i][j]);
printf("\n");
}
}

// Valida que la palabra s se pueda agregar a la matriz m
// en la posición (x, y) y en la dirección (dx, dy)
int valida(char **m, int filas, int columnas, const char *s, int x, int y, int dx, int dy) {
int i, v = 1;

for (i = 0; i < (int)strlen(s); i++, x += dx, y += dy){
if (x < 0 || y < 0 || x >= columnas || y >= filas || (m[y][x] != s[i] && m[y][x] != '\0')){
v = 0;
break;
}
}
if(v==1)
printf("\n%s puede agregarse (x%d, y%d, dx%d, dy%d): %d", s, x, y, dx, dy, v);

return v;
}

// Agrega la palabra s a la sopa de letras
void agrega(char **m, int filas, int columnas, const char *s) {
int i, x, y, dx, dy;

dx = rand() % 3 - 1;
dy = rand() % 3 - 1;
dx = dx == 0 ? 1 : dx;
while (!valida(m, filas, columnas, s, x = rand() % columnas, y = rand() % filas, dx, dy)) ;
for (i = 0; i < (int)strlen(s); i++, x += dx, y += dy)
m[y][x] = s[i];
}

int main() {
// Las palabras que se van a agregar a la sopa de letras
// Deben ser tantas palabras como la definción de PAL
// Escritas en mayúsculas para que se vean bien
char **m, **palabras;
int i;
int filas, columnas, nPalabras;
srand(time(0));

printf("Introduce el numero de caracteres horizontales: ");
scanf("%d",&columnas);
printf("Introduce el numero de caracteres verticales: ");
scanf("%d",&filas);

bool Error = false;

//Obtengo la memoria suficiente para el array que contendrá las palabras a colocar en sopa de letras
printf("Introduce el numero de palabras a colocar: ");
scanf("%d",&nPalabras);
if(( palabras = (char**)malloc(nPalabras*sizeof(char*))) == NULL){
Error != true;
}else{
for ( i = 0; i < nPalabras; i++ ){
if(( palabras[i] = (char*)malloc(LARGOMAX+1)) == NULL )
Error != true;
}
}


//Obtengo la memoria suficiente para el array que contendrá la sopa de letras
if (!Error && ( m = (char**)malloc(filas*sizeof(char*))) == NULL )
{
Error != true;
}else{
for (i = 0; i < filas; i++){
if (( m[i] = (char*)malloc(columnas)) == NULL )
Error != true;
}
}

if(!Error){
PedirPalabras(palabras, nPalabras);
//Lleno la sopa de letra con \0's
inicializa(m,filas,columnas);

//Coloco las palabras en la sopa de letra
for (i = 0; i < nPalabras; i++)
agrega(m, filas, columnas, palabras[i]);

//Muestro como quedan las palabras
muestra(m, filas, columnas);
getchar();

//Relleno los huecos de la sopa de letra
rellena(m, filas, columnas);
getchar();

//Muestro como queda la sopa de letra
muestra(m, filas, columnas);
getchar();
}

//Libero la memoria de la matriz de la sopa de letras
if( m != NULL ){
for ( i = 0; i < filas; i++ )
{
if (m[i] != NULL)
{
free(m[i]);
}
}
}
free(m);

//Libero la memoria de la matriz de las palabras
if( palabras != NULL ){
for ( i = 0; i < nPalabras; i++ )
{
if (palabras[i] != NULL)
{
free(palabras[i]);
}
}
}
free(palabras);
return 0;
}
Saludos.

[aguml]

tienes razon, el codigo donde acomodo las palabras estaba ejecutandose antes de terminar de allocar toda la memoria jajaja.
Ahora me queda crear algo asi como un RandomSuffle que vaya probando todas las combinaciones posibles hasta encontrar una y si las prueba todas y no da con una valida pues que avise con un error. Prueben a crear una sopa de por ejemplo 5x5 y agregen una palabra de 6 letras y veran que no sale nunca del while:
while (!valida(m, filas, columnas, s, x = rand() % columnas, y = rand() % filas, dx, dy)) ;
de la funcion agrega.

Mi idea es algo asi:
largo=rows*columns;
int *lista=malloc (largo*sizeof (int));
for(int x=0;x <largo;x++)
lista[x]=x;
lista = RandomSuffle (lista, largo);

int* RandomSuffle(int *lista, int largo){
//en un for voy recorriendo todos y calculo con rand la nueva posición y lo intercambio.
int pos, aux;
for(int x=0;x<largo;x++){
pos=rand ()%largo;
if(pos != x){
aux=lista [pos];
lista[pos]=lista[x];
lista[x]=aux;
}
}
}

Luego ya fuera de randomsuffle para saber cual es cada posición lo divido entre el número de columnas y me dará la columna y calculo el residuo y me dará la fila.
void ObtenerPosicion (int valor, int *posx, int *posy){
*posx=valor / cols;
*posy=valor % cols;
}

for(int x=0; x<largo; x++){
ObtenerPosicion(lista[x], &posx, &posy);
...
...


Luego:
Uso el mismo método para la orientacion.
largo=8; //son las 8 posibles orientaciones
int orientacion=malloc (largo*sizeof (int));
for(int x=0;x <largo;x++)
orientacion[x]=x;
orientacion = RandomSuffle (orientacion, largo);
for(int x=0; x<largo; x++){
switch (orientacion[x]){
case 0: //norte
...
break;
case 1: //noroeste
...
break;
case 2: //oeste
...
break;
case 3: //suroeste
...
break;
case 4: //sur
...
break;
case 5: //sureste
...
break;
case 6: //este
...
break;
case 7: //noreste
...
break;
}
}
Si no cabe de ninguna manera cojo una nueva posición y repito hasta encontrar donde cabe o hasta usar la última opción posible.
Si cabe tengo que comprobar que case con las letras que ya haya de otras palabras. Para ello tengo que comprobar con un for si hay alguna letra y comprobar que se corresponda. Dependiendo de la orientacion tendré que comprobar que no desborde el array tampoco.

Todo eso está hecho en el movil y aun no lo he probado, solo fue una idea que me vino estando fuera y lo hice en el movil para no olvidarlo pero ¿que opinais? ¿algo mejor que eso?

[aguml]

Buenas amigos, estoy intentando barajar las filas de un array multidimensional y no soy capaz de dar con el modo. Ahora mismo lo tengo asi:
#include <stdio.h>
#include <stdlib.h>
#include <time.h>

void RandomSuffle(int **lista, int nElements){
//en un for voy recorriendo todos y calculo con rand la nueva posición y lo intercambio.
int x, y, pos, *aux;
for(y=0;y<nElements;y++){
pos=rand()%nElements;
if(pos != y){
aux=lista[pos];
lista[pos]=lista[y];
lista[y]=aux;
}
}
}

int main()
{
int z, x, i=0, deltas[8][2];
srand(time(0));
for (z = -1; z <= 1; z++){
for(x = -1; x <= 1; x++){
if(x == 0 && z == 0){
}else{
deltas[i][0]=z;
deltas[i][1]=x;
i++;
}
}
}

for (i = 0; i < 8; i++){
printf("%2i,",deltas[i][0]);
printf("%2i\n",deltas[i][1]);
}

RandomSuffle(deltas, 8);
printf("\n");
for (i = 0; i < 8; i++){
printf("%2i,",deltas[i][0]);
printf("%2i\n",deltas[i][1]);
}
getchar();
return 0;
}

lo que pretendo barajar son los punteros de las filas, o sea, si deltas[0][0]={-1,-1} y la direccion de la fila es 0x12ff00 y deltas[1][0]={1,0} y su direccion es 12ee00 (por decir una), Se suponge que si intercambio esos punteros cambio el orden de la lista sin necesidad de saber cuantas columnas tiene la fila ¿no?
Estoy muy perdido en esto ¿alguien puede ayudarme?

[ecfisa]

Hola aguml.

...
lo que pretendo barajar son los punteros de las filas, o sea, si deltas[0][0]={-1,-1} y la direccion de la fila es 0x12ff00 y deltas[1][0]={1,0} y su direccion es 12ee00 (por decir una), Se suponge que si intercambio esos punteros cambio el orden de la lista sin necesidad de saber cuantas columnas tiene la fila ¿no?

El arreglo está declarado como estático por lo que podrás modificar sus valores pero no el arreglo en sí mismo.
Por otro lado, si envias un arreglo bidimensional como argumento, deberás especificar al menos el tamaño de la segunda dimensión.

Pero sinceramente no sé si interpreté correctamente lo que queres hacer...

Saludos :)

[aguml]

Tenias razón, al crearlo con memoria dinámica ya va perfecto.
Eso cuando lo termine formará parte del código de lo de la sopa de letras. Actualmente hay un bucle en el que dx y dy que son los deltas se calculan con rand. Con esto que he hecho la idea es que pruebe todas las combinaciones válidas sin repetirlas. Esto lo tendría que hacer con todas las coordenadas x e y de la sopa de letras hasta que encuentre una válida o hasta que las pruebe todas y si no se encuentra una válida avise. Actualmente como esta en el código de la sopa de letras se podría quedar en un bucle infinito si no existiese una posición válida.

[aguml]

Asi ha quedado:
#include <stdio.h>
#include <stdlib.h>
#include <time.h>

enum booleanos {false,true};

void RandomSuffle(int **lista, int nElements){
//en un for voy recorriendo todos y calculo con rand la nueva posición y lo intercambio.
int x, y, pos, *aux;
for(y=0;y<nElements;y++){
pos=rand()%nElements;
if(pos != y){
aux=lista[pos];
lista[pos]=lista[y];
lista[y]=aux;
}
}
}

void RellenarDeltas(int **deltas){
int y, x, i=0;

for (y = -1; y <= 1; y++){
for(x = -1; x <= 1; x++){
if(!(x == 0 && y == 0)){
deltas[i][0]=y;
deltas[i][1]=x;
i++;
}
}
}
}

int main()
{
int z, x, i=0, nProbados, **deltas, **coordenadas, nFilas, nColumnas, Error=false;
struct{
int x;
int y;
}posicion;

srand(time(0));

nFilas=8;
nColumnas=2;

//Obtengo memoria dinamicamente para el array que contendrá los deltas
if(( deltas = (int**)malloc(nFilas*sizeof(int*))) == NULL){
Error = true;
}else{
for ( i = 0; i < nFilas; i++ ){
if(( deltas[i] = (int*)malloc(nColumnas*sizeof(int))) == NULL )
Error = true;
}
}

if(!Error){
i=0;
nFilas=10;
nColumnas=8;

nFilas *= nColumnas;
nColumnas=1;
if(( coordenadas = (int**)malloc(nFilas*sizeof(int*))) == NULL){
Error = true;
}else{
for ( i = 0; i < nFilas; i++ ){
if(( coordenadas[i] = (int*)malloc(nColumnas*sizeof(int))) == NULL ){
Error = true;
}
}
}

if(!Error){
for(i=0; i<nFilas; i++)
coordenadas[i][0]=i;

//Barajo las coordenadas posibles
RandomSuffle(coordenadas,nFilas*nColumnas);

nFilas=10;
nColumnas=8;
nProbados=0;

//Obtengo las coordenadas para X e Y
for(i=0; i<nColumnas*nFilas; i++){
posicion.x = coordenadas[i][0]%nColumnas;
posicion.y = coordenadas[i][0]/nColumnas;

RellenarDeltas(deltas);
RandomSuffle(deltas, 8);

for(z=0; z<8; z++){
//Aqui tengo que llamar a la funcion que haga uso de los deltas y de las coordenadas ya barajados
printf("X=%i, Y=%i, deltaX=%i, deltaY=%i\n", posicion.x, posicion.y, deltas[z][0], deltas[z][1]);
nProbados++;
}
}
printf("\nProbados %i opciones", nProbados);
}
}
getchar();
return 0;
}

Para ese caso en concreto probaria 640 posibilidades sin repetir ninguna y digamos que seria aleatorio el orden. Son 10 filas, 8 columnas y por cada posicion se pueden dar 8 combinaciones de deltas diferentes con lo que seria 8*10*8=640. Eso es lo que queria conseguir. Ahora me queda acomodarlo con el de la sopa de letras para que repita eso con cada palabra y listo. Se que tiene un coste de procesado y memoria elevados pero se acaba el problema del bucle infinito cuando no pueda acomodar la palabra.

[aguml]

Bueno amigos, ya tengo el codigo funcionando y va mejor de lo que pensaba jajaja. Solo tengo una duda y es que para obtener memoria y para liberarla uso unas funciones que son copias casi identicas a excepcion del tipo de retorno y del tipo de un parametro de entrada.
Aqui las funciones:
//Libera la memoria de un array de enteros
int** LiberarMemoria(int **dir, int nFilas, int nColumnas)
{
int i;

if( dir != NULL ){
for ( i = 0; i < nFilas; i++ )
{
if (dir[i] != NULL)
{
free(dir[i]);
}
}
}
free(dir);
dir=NULL;

return dir;
}

//Libera la memoria de un array de cadenas
char** LiberarMemoriaCadenas(char **dir, int nFilas, int nColumnas){
int i;

if( dir != NULL ){
for ( i = 0; i < nFilas; i++ )
{
if (dir[i] != NULL)
{
free(dir[i]);
}
}
}
free(dir);
dir=NULL;

return dir;
}

//Obtiene memoria para almacenar un array de cadenas
char** ObtenerMemoriaCadenas(char **dir, int nFilas, int nColumnas){
int Error=false, i;
if(( dir = (char**)malloc(nFilas*sizeof(char*))) == NULL){
Error = true;
}else{
for ( i = 0; i < nFilas; i++ ){
if(( dir[i] = (char*)malloc(nColumnas)) == NULL )
Error = true;
}
}

if(Error){
dir = LiberarMemoriaCadenas(dir, nFilas, nColumnas);
}

return dir;
}

//Obtiene memoria para almacenar un array de punteros a enteros
int** ObtenerMemoria(int **dir, int nFilas, int nColumnas){
int Error=false, i;
if(( dir = (int**)malloc(nFilas*sizeof(int*))) == NULL){
Error = true;
}else{
for ( i = 0; i < nFilas; i++ ){
if(( dir[i] = (int*)malloc(nColumnas)) == NULL )
Error = true;
}
}

if(Error){
dir = LiberarMemoria(dir, nFilas, nColumnas);
}

return dir;
}

¿alguna manera sencilla de hacer que una funcion sirva para ambos casos al obtener memoria y otra sola funcion sirva para liberarla?

[Casimiro Notevi]

Yo diría que esa función de Liberarmemoriacadenas no sirve para nada.
Además devuelve null
Simplemente liberas la variable, no recuerdo si es variable.free o free(variable) o freeandnil(variable)

[aguml]

Bueno, he estado pasandolo todo a C++Builder y la parte de la memoria dinamica me tiene mareado. Esto me funciona pero no se si hago algo mal:
//Obtiene memoria para almacenar un array de punteros a enteros
int** ObtenerMemoria(int **dir, int nFilas, int nColumnas){
int Error=false, i;
if(( dir = (int**)new (std::nothrow) int*[nFilas]) == NULL){
Error = true;
}else{
for ( i = 0; i < nFilas; i++ ){
if(( dir[i] = (int*)new (std::nothrow) int[nColumnas]) == NULL )
Error = true;
}
}

if(Error){
dir = LiberarMemoria(dir, nFilas, nColumnas);
}

return dir;
}

Digamos que lo que obtengo es un array multidimensional del tipo:
int dir[nFilas][nColumnas];

En la pagina de C++ con clase veo esto:
//Array de diez punteros a float:
float **f=new float *[10];
//Cada elemento del array es un array de 10 float
// f es un array de 10*10
f[0][0] = 10.32;
f[9][9] = 21.39;

¿Se supone que es lo mismo que yo hago arriba pero en vez de ser de [nFilas][nColumnas] es de [nFilas][nFilas]? ¿Se puede hacer de esa misma manera lo que yo hago en mi codigo? O sea hacerlo en una sola linea especificando las dos dimensiones y en "dir" sea un puntero a nFilas punteros y que cada uno de esos punteros tenga nColumnas del tipo int.

Y para liberar memoria hago asi:
//Libera la memoria de un array de enteros
int** LiberarMemoria(int **dir, int nFilas, int nColumnas)
{
int i;

if( dir != NULL ){
for ( i = 0; i < nFilas; i++ )
{
if (dir[i] != NULL)
{
delete dir[i];
}
}
}
delete dir;
dir=NULL;

return dir;
}

No se tampoco si hay algo mal pero el codigo funciona sin dar errores. La pregunta es la misma ¿se puede hacer mejor con menos codigo?

[Casimiro Notevi]

Lo que he dicho antes, LiberarMemoria no sirve para nada.Te basta con free(dir)

[aguml]

es que no estoy usando ahora malloc, estoy usando new por lo que tengo que liberar con delete. No estoy muy convencido de que liberando el puntero de punteros se libere toda la memoria allocada para cada puntero. ¿Seguro?

[Casimiro Notevi]

Estás mezclando C y C++ bueno, pues déjalo así si libera correctamente.

[ecfisa]

Hola aguml.

Para liberar la memoria ocupada por una matríz dinámica, básicamente tenes que recorrerla por filas e ir liberando objetos y por último liberar el arreglo.

Con new (C++):

for(int r = 0; r < TOTROWS; r++)
delete[] matriz[r];
delete [] matriz;


Con malloc/calloc (C):

for(r = 0; r < TOTROWS; r++)
free(mat[r]);
free(mat);


Saludos :)

[aguml]

Gracias amigo. Ahora me queda una duda. ¿que diferencia de funcionamiento tienen estos dos codigos?
for(int r = 0; r < TOTROWS; r++)
delete[] matriz[r];
delete [] matriz;
for(int r = 0; r < TOTROWS; r++)
delete matriz[r];
delete matriz;
Ambos codigos funcionan sin dar excepcion y ya me dijiste que el que está bien es el primero pero ¿que hace entonces el segundo? ¿puedes explicarme la diferencia entre ellos?

[ecfisa]

Hola aguml.

En base, no existen arreglos bidimensionales en C/C++. Lo que existen son arreglos unidimensionales de elementos, donde cada uno de ellos es un arreglo.

El operador delete sin los corchetes se utiliza para liberar la memoria ocupada por un objeto, vg.:

int *p = new int;
...
delete p;


El operador delete con los corchetes se utiliza para liberar la memoria ocupada por un arreglo de objetos, vg.:

int *v = new int[5];
...
delete [] v;

En un arreglo de arreglos, primero se liberan los elementos del segundo arreglo y por último el primero.

...
for(int r=0; r < row; r++) delete [] matriz[r];
delete [] matriz;

El segundo código de tu mensaje no es correcto, no le indicas al compilador que "matriz" se trata de un arreglo, lo tratas como un si fuera un solo objeto, nada garantiza que estes liberando correctamente la memoria.

El caso erroneo inverso sería:

int *p = new int;
...
delete [] p; // Error, p no es un arreglo


Saludos :)

[aguml]

Y si con delete no le indicas el tamaño del arreglo ¿como sabe cuantos tiene que liberar? ¿Guarda el número de elementos en alguna tabla interna?

[ecfisa]

Hola aguml.
Y si con delete no le indicas el tamaño del arreglo ¿como sabe cuantos tiene que liberar? ¿Guarda el número de elementos en alguna tabla interna?
Si, es mas o menos así.

Según tengo entendido, cuando se asigna memoria en el heap, el manejador de memoria de C++ agrega una cabecera conteniendo la cantidad de memoria que fué asignada. De este modo no tiene dificultad en saber cuanta memoria le fué asociada a una variariable y por ende liberarla.

Saludos :)