elhacker.net cabecera Bienvenido(a), Visitante. Por favor Ingresar o Registrarse
¿Perdiste tu email de activación?.

 

 


Tema destacado: Los 10 CVE más críticos (peligrosos) de 2020


+  Foro de elhacker.net
|-+  Programación
| |-+  Programación C/C++ (Moderadores: Eternal Idol, Littlehorse, K-YreX)
| | |-+  [C] Paso de arreglos bidimensionales a funciones. (?)
0 Usuarios y 1 Visitante están viendo este tema.
Páginas: [1] Ir Abajo Respuesta Imprimir
Autor Tema: [C] Paso de arreglos bidimensionales a funciones. (?)  (Leído 10,224 veces)
oblivionxor

Desconectado Desconectado

Mensajes: 19


No hay mayor fracaso que apresurar el exito


Ver Perfil
[C] Paso de arreglos bidimensionales a funciones. (?)
« en: 19 Febrero 2013, 17:29 pm »

Hola que tal. Lo que pasa es que en este codigo:
Código
  1. /*Asignacion de valores en arreglos bidimensionales*/
  2. #include <stdio.h>
  3.  
  4. /*Prototipos de funciones*/
  5. void imprimir_arreglo( const int a[2][3] );
  6.  
  7. /*Inicia la ejecucion del programa*/
  8. int main()
  9. {
  10.  int arreglo1[2][3] = { { 1, 2, 3 },
  11.                         { 4, 5, 6 } };                        
  12.  int arreglo2[2][3] = { 1, 2, 3, 4, 5 };
  13.  int arreglo3[2][3] = { { 1, 2 }, { 4 } };
  14.  
  15.  printf( "Los valores en el arreglo 1 de 2 filas y 3 columnas son:\n" );
  16.  imprimir_arreglo( arreglo1 );
  17.  
  18.  printf( "Los valores en el arreglo 2 de 2 filas y 3 columnas son:\n" );
  19.  imprimir_arreglo( arreglo2 );
  20.  
  21.  printf( "Los valores en el arreglo 3 de 2 filas y 3 columnas son:\n" );
  22.  imprimir_arreglo( arreglo3 );
  23.  
  24.  return 0;
  25. }  /*Fin de main*/
  26.  
  27. /*Definiciones de funciones*/
  28. void imprimir_arreglo( const int a[2][3] )
  29. {
  30.  int i;  /*Contador filas*/
  31.  int j;  /*Contador columnas*/
  32.  
  33.  for (i = 0; i <=1; i++)
  34.  {
  35.    for (j = 0; j <= 2; j++)
  36.    {
  37.      printf( "%d ", a[i][j] );
  38.    }
  39.  
  40.    printf( "\n" );
  41.  }
  42. } /*Fin de funcion imprime_arreglo*/
  43.  

Cuando compilo de esa manera me da estos errores mi compilador:
Citar
ArreglosBidimensionales.c: In function ‘main’:
ArreglosBidimensionales.c:16:3: warning: passing argument 1 of ‘imprimir_arreglo’ from incompatible pointer type [enabled by default]
ArreglosBidimensionales.c:5:6: note: expected ‘const int (*)[3]’ but argument is of type ‘int (*)[3]’
ArreglosBidimensionales.c:19:3: warning: passing argument 1 of ‘imprimir_arreglo’ from incompatible pointer type [enabled by default]
ArreglosBidimensionales.c:5:6: note: expected ‘const int (*)[3]’ but argument is of type ‘int (*)[3]’
ArreglosBidimensionales.c:22:3: warning: passing argument 1 of ‘imprimir_arreglo’ from incompatible pointer type [enabled by default]
ArreglosBidimensionales.c:5:6: note: expected ‘const int (*)[3]’ but argument is of type ‘int (*)[3]’

Pero cuando compilo quitandole el calificador de tipo const al prototipo y definicion de funciones es decir asi:
Código
  1. /*Prototipos de funciones*/
  2. void imprimir_arreglo( int a[2][3] );
  3.  
  4. .......
  5.  
  6. /*Definiciones de funciones*/
  7. void imprimir_arreglo( int a[2][3] )
  8. {
  9.  
Si puedo compilar correctamente.

Por que pasa eso? Por que en arreglos unidimensionales si puedo compilar con el calificador const y en los bidimensionales no? Alguien me puede ayudar con esta duda?
Por cierto uso el compilador GNU GCC.
Agradecimientos por adelantado.


En línea

Sputnik_

Desconectado Desconectado

Mensajes: 80



Ver Perfil
Re: [C] Paso de arreglos bidimensionales a funciones. (?)
« Respuesta #1 en: 19 Febrero 2013, 17:43 pm »

en c++ funciona  :xD
saludos  


« Última modificación: 19 Febrero 2013, 17:49 pm por PajaroUyUyUy » En línea

Las personas lo suficientemente locas como para pensar que pueden cambiar el mundo son las que lo cambian.
leosansan


Desconectado Desconectado

Mensajes: 1.314


Ver Perfil
Re: [C] Paso de arreglos bidimensionales a funciones. (?)
« Respuesta #2 en: 19 Febrero 2013, 18:25 pm »

Ya te lo está diciendo el compilador: espera un const int y tú le mandas un int. Lo que quiere decir que tienes mal tipificadaos los arreglos, que deberían ser:

Citar
....................................................................
  const int arreglo1[2][3] = { { 1, 2, 3 }, { 4, 5, 6 } };                      

  const int arreglo2[2][3] = { 1, 2, 3, 4, 5 };
  
  const int arreglo3[2][3] = { { 1, 2 }, { 4 } };
   .......................................................................

Saluditos!.
En línea

oblivionxor

Desconectado Desconectado

Mensajes: 19


No hay mayor fracaso que apresurar el exito


Ver Perfil
Re: [C] Paso de arreglos bidimensionales a funciones. (?)
« Respuesta #3 en: 19 Febrero 2013, 19:34 pm »

leosansan pero por que cuando declaro arreglos unidimensionales, aunque no los declare como const, si puedo compilar correctamente cuando paso los arreglos a parametros const de una funcion?
Asi mira:
Código
  1. #include <stdio.h>
  2.  
  3. void intenta_modificar_arreglo( const int b[] );
  4.  
  5. /* Inicia la ejecucion */
  6. int main()
  7. {
  8. int a[] = { 1, 2, 10 };
  9.  
  10. intenta_modificar_arreglo( a );
  11.  
  12. printf( "%d %d %d\n", a[0], a[1], a[2] );
  13.  
  14. return 0;
  15. } /* Fin de main */
  16.  
  17. /*------------------Definicion de funciones-----------------------*/
  18. void intenta_modificar_arreglo( const int b[] )
  19. {
  20. b[0] /= 2;
  21. b[1] /= 2;
  22. b[2] /= 2;
  23. } /* Fin de funcion intenta_modificar_arreglo */
  24.  
Que es lo que pasa, por que en arreglos unidimensionales si se puede evadir la declaracion const y en los bidimensionales no?? Esa es mi duda???
En línea

leosansan


Desconectado Desconectado

Mensajes: 1.314


Ver Perfil
Re: [C] Paso de arreglos bidimensionales a funciones. (?)
« Respuesta #4 en: 19 Febrero 2013, 22:38 pm »

.......................... Esa es mi duda???

Y me has creado otra a mí. Espero que alguien como rir o afín nos saque de la duda. :o
 por cierto, para mantener el paralelismo con el bidimensional he usado:
Código
  1. #include <stdio.h>
  2.  
  3. void intenta_modificar_arreglo( const int b[3] );
  4.  
  5. /* Inicia la ejecucion */
  6. int main()
  7. {
  8. int a[3] = { 1, 2, 10 };
  9.  
  10. intenta_modificar_arreglo( a );
  11.  
  12.  
  13. return 0;
  14. } /* Fin de main */
  15.  
  16. /*------------------Definicion de funciones-----------------------*/
  17. void intenta_modificar_arreglo( const int b[3] )
  18. {
  19. int j;
  20. for (j = 0; j <= 2; j++)
  21.    {
  22.      printf( "%d ", b[j] );
  23.    }
  24.  
  25. } /* Fin de funcion intenta_modificar_arreglo */
  26.  

Pero no "cantan" ahora los warnings :o :o

Saluditos!.
« Última modificación: 19 Febrero 2013, 22:42 pm por leosansan » En línea

oblivionxor

Desconectado Desconectado

Mensajes: 19


No hay mayor fracaso que apresurar el exito


Ver Perfil
Re: [C] Paso de arreglos bidimensionales a funciones. (?)
« Respuesta #5 en: 20 Febrero 2013, 04:48 am »

Si espero que nos saquen de la duda :c ojala y sean tan amables de aclararnoslo.
En línea

amchacon


Desconectado Desconectado

Mensajes: 1.211



Ver Perfil
Re: [C] Paso de arreglos bidimensionales a funciones. (?)
« Respuesta #6 en: 20 Febrero 2013, 13:50 pm »

En C++ tira perfecto, creo que tiene que ver con las limitaciones de C y la pila.

Puedes crearlo dinámicamente y entonces si te irá:

Código
  1. /*Asignacion de valores en arreglos bidimensionales*/
  2. #include <stdio.h>
  3. #include <stdlib.h>
  4.  
  5. /*Prototipos de funciones*/
  6. void imprimir_arreglo( const int** a);
  7.  
  8. /*Inicia la ejecucion del programa*/
  9. int main()
  10. {
  11.  int i = 0;
  12.  int** arreglo1 = (int**)malloc(3*sizeof(int*));
  13.  
  14.  for (i = 0; i < 3;i++)
  15.        arreglo1[i] = (int*)malloc(2*sizeof(int));
  16.  
  17.  //int** arreglo2[2][3] = { {1, 2, 3},{ 4, 5, 6 }};
  18.  //int** arreglo3[2][3] = { { 1, 2 }, { 4 } };
  19.  
  20.  printf( "Los valores en el arreglo 1 de 2 filas y 3 columnas son:\n" );
  21.  imprimir_arreglo((const int**) arreglo1 );
  22.  
  23.  printf( "Los valores en el arreglo 2 de 2 filas y 3 columnas son:\n" );
  24.  //imprimir_arreglo( arreglo2 );
  25.  
  26.  printf( "Los valores en el arreglo 3 de 2 filas y 3 columnas son:\n" );
  27.  //imprimir_arreglo( arreglo3 );
  28.  
  29.  return 0;
  30. }  /*Fin de main*/
  31.  
  32. /*Definiciones de funciones*/
  33. void imprimir_arreglo( const int** a)
  34. {
  35.  int i;  /*Contador filas*/
  36.  int j;  /*Contador columnas*/
  37.  
  38.  for (i = 0; i <=1; i++)
  39.  {
  40.    for (j = 0; j <= 2; j++)
  41.    {
  42.      printf( "%d ", a[i][j] );
  43.    }
  44.  
  45.    printf( "\n" );
  46.  }
  47. } /*Fin de funcion imprime_arreglo*/
En línea

Por favor, no me manden MP con dudas. Usen el foro, gracias.

¡Visita mi programa estrella!

Rar File Missing: Esteganografía en un Rar
BatchianoISpyxolo

Desconectado Desconectado

Mensajes: 166


Ver Perfil
Re: [C] Paso de arreglos bidimensionales a funciones. (?)
« Respuesta #7 en: 20 Febrero 2013, 23:51 pm »

Te pego una práctica que hice hará 2 meses o así para que veas más o menos el manejo de arrays bidimensionales en C.

Código
  1. /*
  2.  
  3. FIC - 2º GRADO - Algortimos
  4. Practica 4
  5. Maquina donde se han testado los algoritmos:
  6. Equipo portatil personal. Intel(R) Core(TM) i3 CPU M 370 @ 2.40GHz x64
  7.  
  8. */
  9.  
  10. #include <stdio.h>
  11. #include <stdlib.h>
  12. #include <sys/time.h>
  13. #include <limits.h>
  14. #include <math.h>
  15. #include "lista.h"
  16.  
  17. typedef int ** matriz;
  18.  
  19. // algoritmo de prim
  20. lista prim(matriz m, int tam) {
  21.    int min, i, j, r, k=0;
  22.    arista a;
  23.    lista l;
  24.    int *masProximo = (int *) malloc(tam*sizeof(int));
  25.    int *distanciaMinima = (int *) malloc(tam*sizeof(int));
  26.    crear_lista(&l);
  27.    distanciaMinima[0] = -1;
  28.    for(i = 1; i < tam; i++) {
  29.        masProximo[i] = 0;
  30.        distanciaMinima[i] = m[i][0];
  31.    }
  32.    for (r=1; r<tam; r++) { /* bucle voraz */
  33.        min = INT_MAX;
  34.        for (j=1;j<tam;j++) {
  35.            if (0<=distanciaMinima[j] && distanciaMinima[j]<min) {
  36.                min = distanciaMinima[j];
  37.                k = j;
  38.            }
  39.        }
  40. a.x = masProximo[k]; a.y = k; a.peso = min;
  41. insertar(a,&l);
  42. distanciaMinima[k] = -1;
  43. for (j=1;j<tam;j++) {
  44. if (m[j][k] < distanciaMinima[j]) {
  45. distanciaMinima[j] = m[j][k];
  46. masProximo[j] = k;
  47. }
  48. }
  49.    }
  50.    free(masProximo);
  51.    free(distanciaMinima);
  52.    return l;
  53. }
  54.  
  55. // crea una matriz
  56. matriz crear_matriz(int n) {
  57.    int i;
  58.    matriz aux;
  59.    if ((aux = (int **) malloc(n*sizeof(int *))) == NULL)
  60.        return NULL;
  61.    for (i=0; i<n; i++)
  62.        if ((aux[i] = (int *) malloc(n*sizeof(int))) == NULL)
  63.            return NULL;
  64.    return aux;
  65. }
  66.  
  67. // genera la matriz del primer ejemplo
  68. matriz matriz_primer_ejemplo() {
  69. int i,j;
  70. matriz m = (matriz)crear_matriz(5);
  71. m[0][1] = 1; m[0][2] = 8; m[0][3] = 4; m[0][4] = 7;
  72. m[1][2] = 2; m[1][3] = 6; m[1][4] = 5;
  73. m[2][3] = 9; m[2][4] = 5;
  74. m[3][4] = 3;
  75. for (i=0; i<5; i++)
  76. for (j=0; j<=i; j++)
  77. if (i==j)
  78. m[i][j] = 0;
  79. else
  80. m[i][j] = m[j][i];
  81. return m;
  82. }
  83.  
  84. // genera la matriz del segundo ejemplo
  85. matriz matriz_segundo_ejemplo() {
  86. int i,j;
  87. matriz m = (matriz)crear_matriz(4);
  88. m[0][1] = 1; m[0][2] = 4; m[0][3] = 7;
  89. m[1][2] = 2; m[1][3] = 8;
  90. m[2][3] = 3;
  91. for (i=0; i<4; i++)
  92. for (j=0; j<=i; j++)
  93. if (i==j)
  94. m[i][j] = 0;
  95. else
  96. m[i][j] = m[j][i];
  97.  
  98. return m;
  99. }
  100.  
  101. // genera la matriz del tercer ejemplo
  102. matriz matriz_tercer_ejemplo() {
  103. int i,j;
  104. matriz m = (matriz)crear_matriz(7);
  105. m[0][1] = 7; m[0][2] = 99; m[0][3] = 5; m[0][4] = 99; m[0][5] = 99; m[0][6] = 99;
  106. m[1][2] = 8; m[1][3] = 9; m[1][4] = 7; m[1][5] = 99; m[1][6] = 99;
  107. m[2][3] = 99; m[2][4] = 5; m[2][5] = 99; m[2][6] = 99;
  108. m[3][4] = 15; m[3][5] = 6; m[3][6] = 99;
  109. m[4][5] = 8; m[4][6] = 9;
  110. m[5][6] = 11;
  111. for (i=0; i<7; i++)
  112. for (j=0; j<=i; j++)
  113. if (i==j)
  114. m[i][j] = 0;
  115. else
  116. m[i][j] = m[j][i];
  117. return m;
  118. }
  119.  
  120. void inicializar_matriz(matriz m, int n) {
  121.    /* Crea un grafo completo no dirigido con pesos aleatorios entre 1 y n */
  122.    int i, j;
  123.    for (i=0; i<n; i++)
  124.        for (j=i+1; j<n; j++)
  125.            m[i][j] = rand() % n + 1;
  126.    for (i=0; i<n; i++)
  127.        for (j=0; j<=i; j++)
  128.            if (i==j)
  129.                m[i][j] = 0;
  130.            else
  131.                m[i][j] = m[j][i];
  132. }
  133.  
  134. void liberar_matriz(matriz m, int n) {
  135.    int i;
  136.    for (i=0; i<n; i++)
  137.        free(m[i]);
  138.    free(m);
  139. }
  140.  
  141. void solucion(lista l) {
  142.  
  143.    pnodo it = primera(l);
  144.    int peso_total = 0;
  145.    printf("Aristas: ");
  146.    while (it != NULL) {
  147.        printf("(%d, %d) ", it->elemento.x, it->elemento.y);
  148.        peso_total += it->elemento.peso;
  149.        it = siguiente(it);
  150.    }
  151.    printf("\nPeso total minimo: %d\n", peso_total);
  152.    eliminar_lista(&l);
  153. }
  154.  
  155. void test () {
  156. printf("\n- test para probar el correcto funcionamiento del algoritmo -\n\n");
  157. matriz m = matriz_primer_ejemplo();
  158. matriz n = matriz_segundo_ejemplo();
  159. matriz o = matriz_tercer_ejemplo();
  160. printf("Primer ejemplo.\n");
  161. solucion(prim(m,5));
  162. printf("\nSegundo ejemplo.\n");
  163. solucion(prim(n,4));
  164. printf("\nTercer ejemplo.\n");
  165. solucion(prim(o,7));
  166. printf("\n");
  167. liberar_matriz(m,5);
  168. liberar_matriz(n,4);
  169. liberar_matriz(o,7);
  170. }
  171.  
  172. double microsegundos() {
  173. struct timeval t;
  174. if (gettimeofday(&t, NULL) < 0 )
  175. return 0.0;
  176. return (t.tv_usec + t.tv_sec * 1000000.0);
  177. }
  178.  
  179. double obtener_tiempo(int N, int *umbral){
  180. #define ITER 1000
  181. int i;
  182. double t1, t2, t3, t4, t5, t6, t;
  183. matriz M = crear_matriz(N);
  184. inicializar_matriz(M,N);
  185. t1 = microsegundos();
  186. prim(M,N);
  187. t2 = microsegundos();
  188. t = t2-t1;
  189. liberar_matriz(M,N);
  190. *umbral = 0; // t < 500us
  191. if (t<500) {
  192. *umbral = 1; // t >= 500us
  193. matriz A = crear_matriz(N);
  194. // t3 = tiempo de inicializacion + tiempo prim
  195. for (i=1; i<=ITER; i++) {
  196. t1 = microsegundos();
  197. inicializar_matriz(A,N);
  198. prim(A,N);
  199. t2 = microsegundos();
  200. t3 += (t2-t1);
  201. }
  202. // t6 = tiempo de inicializacion
  203. for (i=1; i<=ITER; i++) {
  204. t4 = microsegundos();
  205. inicializar_matriz(A,N);
  206. t5 = microsegundos();
  207. t6 += (t5-t4);
  208. }
  209. t = (t3-t6) / ITER;
  210. liberar_matriz(A,N);
  211. }
  212. return (t<0 ? -t : t);
  213. }
  214.  
  215. void medicion_tiempos() {
  216.  
  217. #define REPS 6
  218. int n, N, it; // variables para control de bucles y parámetros de entrada
  219. int umbral; // umbral de tiempo de ejecucion (500 us) { 1 = Supera umbral, 0 = No supera umbral }
  220. double t; // tiempo de ejecucion
  221. double h, g, f; // valores para acotar
  222.  
  223. printf("- Medicion de tiempos del algoritmo -\n\n");
  224.  
  225. printf("-> h(n) = cota subestimada\n");
  226. printf("-> g(n) = cota ajustada\n");
  227. printf("-> f(n) = cota sobrestimada\n");
  228. printf("\n-------------------------------------------------------------------------\n");
  229. printf("\n%9s%13s%13s%13s%13s%10s\n","n", "t(n)", "t(n)/h(n)", "t(n)/g(n)", "t(n)/f(n)", "Umbral"); // encabezado
  230.  
  231. n = 16;
  232. for (it=1; it<=REPS; it++) {
  233. n = n*2-1;
  234. N = (int)sqrt(n);
  235. t = obtener_tiempo(N, &umbral);
  236. h = t / pow(N*N, 1.8); // t(n)/h(n)
  237. g = t / pow(N*N, 2); // t(n)/g(n)
  238. f = t / pow(N*N, 2.2); // t(n)/f(n)
  239. printf("%9d%13.6f%12.6f%13.6f%13.6f%8d\n", N*N, t, h, g, f, umbral);
  240. }
  241. printf("\n-------------------------------------------------------------------------\n");
  242.  
  243. }
  244.  
  245. int main () {
  246.  
  247. printf("\nPractica 4: Analisis del algortimo de Prim.\n");
  248. test();
  249. medicion_tiempos();
  250.  
  251. }
  252.  
En línea

Puede que desees aprender a programar desde 0: www.espascal.es
rir3760


Desconectado Desconectado

Mensajes: 1.639


Ver Perfil
Re: [C] Paso de arreglos bidimensionales a funciones. (?)
« Respuesta #8 en: 22 Febrero 2013, 06:06 am »

Por partes.

Por que en arreglos unidimensionales si puedo compilar con el calificador const
Primero porque las funciones no ven en ningún momento un array, cuando de declara una función en la forma:
Código
  1. int fn(int a[]);
  2.  
  3. /* O */
  4.  
  5. int fn(int a[N]);
Esta se procesa como si la declaración fuera:
Código
  1. int fn(int *a);
Es por ello que no puede obtenerse el tamaño del array pasado como argumento y tampoco importa indicar el numero de elementos de este, la función simplemente recibe un puntero: la dirección en memoria de su primer elemento.

Segundo por que a una función que espere como argumento un puntero a objeto constante (tipo "const T *") puede pasarse un puntero sin el calificador const (tipo "T *") sin ningún problema: la conversión implícita de un tipo a otro ("T *" ==> "const T *") se aplica de forma transparente salvo una excepción.

Un ejemplo para explicar de una forma mas clara los dos puntos anteriores:
Código
  1. #include <stdio.h>
  2. #include <stdlib.h>
  3.  
  4. int suma(const int *valor, size_t num_elem);
  5.  
  6. int main(void)
  7. {
  8.   int valor[] = {1, 2, 3};
  9.   size_t num_elem = sizeof valor / sizeof valor[0];
  10.  
  11.   printf("Suma == %d\n", suma(valor, num_elem));
  12.  
  13.   return EXIT_SUCCESS;
  14. }
  15.  
  16. int suma(const int *valor, size_t num_elem)
  17. {
  18.   size_t i;
  19.   int total;
  20.  
  21.   total = 0;
  22.   for (i = 0; i < num_elem; i++)
  23.      total += valor[i];
  24.  
  25.   return total;
  26. }

y en los bidimensionales no?
Porque la excepción son los "arrays bidimensionales".

Aquí un paréntesis: C no tiene punteros "dobles", "triples", etc. como tampoco arrays "unidimensionales", "bidimensionales", etc. solo tiene punteros y arrays. Que el tipo apuntado sea también un puntero o el elemento del array un array es otra historia.

Cuando se pasa un array de arrays como argumento de una función esta recibe la dirección de su primer elemento, si el tipo del array es "T [N][M]" la función recibe un puntero de tipo "T (*)[M]".

Y aquí la conversión implícita "T *" ==> "const T *" falla porque el calificador const no se aplica al array, se aplica a sus elementos. Es por ello que tu compilador genera el mensaje de tipos distintos:
Citar
ArreglosBidimensionales.c:5:6: note: expected ‘const int (*)[3]’ but argument is of type ‘int (*)[3]’

La única solución es declarar al array utilizando const o bien realizar la conversión explicita en la llamada a función.

Un saludo
En línea

C retains the basic philosophy that programmers know what they are doing; it only requires that they state their intentions explicitly.
--
Kernighan & Ritchie, The C programming language
oblivionxor

Desconectado Desconectado

Mensajes: 19


No hay mayor fracaso que apresurar el exito


Ver Perfil
Re: [C] Paso de arreglos bidimensionales a funciones. (?)
« Respuesta #9 en: 22 Febrero 2013, 06:45 am »

Wow rir quedo todo superclaro! Muchisimas gracias por tu respuesta! Saludos.
En línea

Páginas: [1] Ir Arriba Respuesta Imprimir 

Ir a:  

Mensajes similares
Asunto Iniciado por Respuestas Vistas Último mensaje
Programa Orientado a Objetos en Java con arreglos bidimensionales :)
Java
Neostream 3 42,941 Último mensaje 1 Marzo 2008, 18:36 pm
por **Adem**
Parametros de entrada, arreglos bidimensionales « 1 2 »
.NET (C#, VB.NET, ASP)
greenselves 13 9,045 Último mensaje 16 Marzo 2010, 05:45 am
por [D4N93R]
arreglos bidimensionales y funciones
Programación C/C++
m@o_614 3 1,946 Último mensaje 16 Julio 2013, 22:33 pm
por eferion
duda con arreglos bidimensionales
Programación C/C++
nicolas04 1 1,159 Último mensaje 26 Junio 2014, 21:23 pm
por Flakito81
Paso de funciones a otras funciones
Programación C/C++
eaz95 1 1,015 Último mensaje 18 Julio 2017, 11:59 am
por ivancea96
WAP2 - Aviso Legal - Powered by SMF 1.1.21 | SMF © 2006-2008, Simple Machines