Mensajes

Hola. Quería preguntar si el hecho de que un arreglo se apunte a si mismo es coincidencia o es una característica de ANSI C, es decir, la dirección del arreglo y la dirección a la que apunta el arreglo es la misma (al menos eso me pasa con MinGW-w64).

Código (c) [Seleccionar] Expandir

int arreglo[4];

if(arreglo == &arreglo) { // Siempre me da 'true'
    ...
}

Gracias

En C el paso por referencia o valor se confunde mucho. Aunque parezca extraño, todo en C se pasa por valor. Cuando pasas un arreglo por parámetros lo que pasas es una copia de la dirección al primer byte del arreglo.

Algunos interpretan que cuando una función pide una dirección de una variable la variable en sí es pasada por referencia, pues la función puede cambiar el valor de la variable, pero no se ha de confundir el paso por valor por el paso por referencia. Estas definiciones están mucho más claras en C++

No es un printf "vacío". Lo que hace ese printf es imprimir un espacio. Es como si pusieras putc(' '). Ahí hay un espacio. En ANSI C no puedes moverte por la consola con un sistema de coordenadas. Como mucho, puedes hacer lo que se hace en el código, y es imprimir línea a línea el arbol

El árbol es el siguiente:

Código [Seleccionar] Expandir

       
       *
      ***
     *****
    *******
    *********
   ***********
  *************

Como ves, antes de los asteriscos que forman el árbol hay espacios.

Para la primera línea, se imprimen 9 espacios, para la segunda 8, para la tercera 7... y para la última, 0 espacios. Eso es lo que hace el primer for. El segundo for imprime los asteriscos.

O... podrías interpretar el arreglo bidimensional como uno unidimensional:

Código (c) [Seleccionar] Expandir

#include <stdio.h>

#define N 4  //Columnas
#define M 5  //Filas

int main(){
int i = 0, j;
int max = M*N;
int matriz_descendente[M][N],matriz_ascendente[M][N];

while(i < max){
((int *)matriz_descendente)[i] = max - i;
((int *)matriz_ascendente)[i] = i+1;
i++;
}

for(i = 0; i < M; i++) {
for(j = 0; j < N; j++)
fprintf(stdout, "%i ", matriz_ascendente[i][j]);

fputc('\n', stdout);
}
fputc('\n', stdout);

for(i = 0; i < M; i++) {
for(j = 0; j < N; j++)
fprintf(stdout, "%i ", matriz_descendente[i][j]);

fputc('\n', stdout);
}

return 0;
}

[caracteres]

Sinceramente, no comprendo el problema. Primero, si quieres que la matriz tenga caracteres, ¿por qué guardas los valores en un arreglo bidimensional de enteros? ¿No sería mejor usar char m[16][16]? Entonces en la asignación podrías hacer m[ i][j] = '&' o el carácter especial que quieras.

Por otra parte, no comprendo tampoco el 'else if' del código. No entiendo su función.

Si lo que quieres hacer es que la diagonal principal tenga uno de los caracteres mencionados o el elemento esté vacío, podrías crear un arreglo de caracteres como este:

Código (c) [Seleccionar] Expandir

const char caracteres[] = {'\0', '*', '/', '+', '-', '%', '&', '$'};

y cuando vayas a asignar algo a un elemento de la diagonal, podrías generar un número aleatorio entre 0 y el número de caracteres especiales:

Código (c) [Seleccionar] Expandir

matriz[i][j] = caracteres[rand()%8];

Nota aclaratoria antes de la explicación: un número al que le sigue una b, significa que está representado en binario (es para aclarar, no es porque sea así)

Lo que hace el operador | no es separar argumenots, sino que los combina sumando bit a bit. Por ejemplo, si haces 10101b | 11100b obtendrás como resultado 11101b. Básicamente, sumas bit a bit. Entonces, ¿en qué se diferencia de una suma normal? la diferencia reside en que si sumas dos bits con valor 1 no habrá carry. Es decir, si sumáramos 011b + 001b obtendríamos lo siguiente:

Código [Seleccionar] Expandir

011b
+001b
____
100b

Sin embargo, si aplicamos el operador | obtendríamos

Código [Seleccionar] Expandir

011b
|001b
____
011b

Entonces, una de las utilidades de este operador es el que mencionas. Lo que hace es asignar un bit de los 32 que tiene un unsigned int a cada bandera.

Por ejemplo, a GLUT_RGBA podríamos asignarle el primer bit, a GLUT_RGB el segundo bit, a GLUT_INDEX el tercer bit, a GLUT_SINGLE el cuarto bit...

Entonces

Código [Seleccionar] Expandir

GLUT_RGBA   = 00000000000000000000000000000001b
GLUT_RGB    = 00000000000000000000000000000010b
GLUT_INDEX  = 00000000000000000000000000000100b
GLUT_SINGLE = 00000000000000000000000000001000b

Por lo tanto, al hacer GLUT_RGB | GLUT_INDEX, lo que haces es dar como resultado un entero con los bits de GLUT_RGBA y GLUT_INDEX activados, y así GLUT puede saber qué banderas has activado. Lo malo es que solo puedes pasar como máximo 32 banderas, puesto que un entero suele ocupar 4 bytes (32 bits).

Solo te tienes que plantear: ¿de qué forma está organizado mi árbol? Una vez sabido eso, puedes establecer una regla en pseudocódigo con la cual eliminas un árbol con dos hijos.

Por ejemplo, dependiendo de la estructura del árbol, solo eliminaría la rama de la derecha, o la de la izquierda.

Sinceramente, no sé que ejemplo poner con árboles binarios y libros XDD Pon la estructura que sigue el árbol y a ver si se nos ocurren ideas para establecer las reglas de eliminación de un nodo.

No soy un experto en árboles binarios (lo digo en serio), pero cuando eliminas un nodo de este, ¿no tienes que eliminar también a sus hijos, "nietos" y demás nodos conectados directamente o indirectamente al nodo a eliminar?

Maravilloso

Gracias!

Si, pero no me refiero a si los datos quedan guardados, que supongo que si. A lo que me refiero, es, si por ejemplo mi programa ha asignado 100 bytes de memoria dinámica y el programa se cierra sin haber llamado a free, entonces mi pregunta es si a otro programa se le podrían asignar esos mismos 100 bytes o no.

Básicamente, pregunto que si al hacer return en la función main habiendo llamado a malloc, esta instrucción "llama" a free liberando toda la memoria dinámica usada por el programa, o esto lo hace el sistema operativo, o tendría que reiniciar el ordenador porque esa memoria ha quedado asignada a un programa que ya se ha cerrado y "se ha perdido la referencia a esa memoria dinámica". Gracias!