User Tag List

Página 2 de 2 PrimerPrimer 12
Resultados 16 al 24 de 24

Tema: Paso de matrices a funciones

  1. #16
    Fecha de ingreso
    Jun 2006
    Mensajes
    4,130
    Agradecer
    731
    Agradecido 437 veces en 275 posts
    Mencionado
    32 Post(s)
    Tagged
    0 Tema(s)
    Entradas de blog
    7
    Cita Iniciado por hi-ban Ver mensaje
    Por cierto... ¿qué es lo que quieres que haga el código? Supongo que hacer algun tipo de multiplicación entre dos arrays... pero ¿como los quieres multiplicar exactamente?
    Tal parece un ejercicio típico de ciclo formativo para habituarse con el uso de arrays. A nosotros nos hicieron hacer uno que calculase la regla de Cramer de dos arrays que pasábamos como argumento.
    _
    .

  2. #17
    Fecha de ingreso
    Jul 2009
    Mensajes
    8,264
    Agradecer
    664
    Agradecido 290 veces en 222 posts
    Mencionado
    48 Post(s)
    Tagged
    0 Tema(s)
    Cita Iniciado por akualung Ver mensaje
    Tienes razón, no me había fijado en el bucle donde el tío ha metido ahí, hardcodeado, el tamaño del array que recibe esa función. Pero pregunto, y de ahí lo que he dicho antes de "caduco". si en C le pasas un array a una función (un array que se supone que viene ya con una serie de valores dentro y por lo tanto, ya tendrá un tamaño determinado) por qué has de pasar el tamaño del array como otro parámetro adicional en vez de simplemente sacarlo de alguna manera similar como se hace en programación orientada a objetos con un sencillo arrayQueAcabamosDeRecibir.length()?

    Sí, lo sé: programación orientada a objetos != programación estructurada... Pero aún así. Encuentro muy fuerte que, en C, si pasas un array a una función, "pierdas" su tamaño y por lo tanto lo tengas que enviar como un parámetro adicional (si es que he entendido bien el error que le está pasando a OP).
    como dices, es diferente, en C no hay objetos...

    tiene su logica, aunque es un poco complejo de explicar, veamos...

    partamos de la base de que sizeof se resuelve en tiempo de compilacion, no hay una funcion sizeof como tal, sino que el compilador la resuelve y coloca el valor constante en ese lugar del codigo. entonces, C no necesita almacenar el tamaño del array para ser accedido en runtime, asi que no hay forma de saber el tamaño del array en una funcion.

    tambien decir que no son objetos, lo que pasas es el dato en si, en el caso de arrays, se pasa el puntero (tampoco se pasa el array por valor, solo por referencia), aunque podrias si quieres pasar una estructura del tipo [ int size; int * array ], tendrias casi un objeto...

    Código:
    #include <stdio.h>
    
    typedef struct {
        int sz;
        int * array;
    } blah;
    
    
    void multiply(blah a, blah b){
    printf("\nTamaño de a = %d\n", a.sz);
    printf("Tamaño de b = %d\n", b.sz);
    
    printf("a[0]=%d\n", a.array[0]);
    printf("b[1]=%d\n", b.array[1]);
    
    }
    
    int main(int argc, const char * argv[]) {
    int a[] = { 9, 2, 3, 4, 5, 6, 7, 8 };
    int b[] = { 4, 3, 2, 1 };
    int a1[] = { 13, 53, 44, 1 };
    int b1[] = { 99, 33 };
    
    blah blah_a, blah_b;
    
    printf("sizeof(int)=%lu\n", sizeof(int));
    
    blah_a.sz = sizeof(a)/sizeof(*a); blah_a.array = a;
    blah_b.sz = sizeof(b)/sizeof(*b); blah_b.array = b;
    
    printf("Tamaño de a = %d\n", (int)(sizeof(a)/sizeof(int)));
    printf("Tamaño de b = %d\n", (int)(sizeof(b)/sizeof(int)));
    multiply(blah_a,blah_b);
    
    printf ("------------\n");
    
    blah_a.sz = sizeof(a1)/sizeof(*a1); blah_a.array = a1;
    blah_b.sz = sizeof(b1)/sizeof(*b1); blah_b.array = b1;
    
    printf("Tamaño de a1 = %d\n", (int)(sizeof(a1)/sizeof(int)));
    printf("Tamaño de b1 = %d\n", (int)(sizeof(b1)/sizeof(int)));
    multiply(blah_a,blah_b);
    
    return 0;
    
    }
    resultado:

    sizeof(int)=4
    Tamaño de a = 8
    Tamaño de b = 4

    Tamaño de a = 8
    Tamaño de b = 4
    a[0]=9
    b[1]=3
    ------------
    Tamaño de a1 = 4
    Tamaño de b1 = 2

    Tamaño de a = 4
    Tamaño de b = 2
    a[0]=13
    b[1]=33
    despues podriamos decir que una funcion donde hace uso de sizeof (resuelto en tiempo de compilacion) de sus parametros arrays, carece de reutilidad para arrays de diferentes sizes...

    el ejemplo es una tonteria, pero bueno, para ejemplificar opciones...

    -----Actualizado-----

    veo que @AJMurphy solo tiene un mensaje, seguramente entro al foro para consultar y puso esta consulta en cientos de sitios, y tal vez ya le respondieron en otro lugar...
    ...

  3. El siguiente usuario agradece a SplinterGU este mensaje:

    akualung (16/06/2017)

  4. #18
    Fecha de ingreso
    Feb 2006
    Mensajes
    4,861
    Agradecer
    20
    Agradecido 767 veces en 457 posts
    Mencionado
    40 Post(s)
    Tagged
    0 Tema(s)
    Cita Iniciado por akualung Ver mensaje
    Hombre, no me dirás que el ansi C no es del año de la catapúm. Casi toda la programación en C actual es C#, no?
    Cabrito, esos chistes no se dicen sin avisar que casi me atraganto con la coca cola... toda la programación con C# ... juarfs juarfs juarfs...
    Zhorro

  5. #19
    Fecha de ingreso
    Jun 2006
    Mensajes
    4,130
    Agradecer
    731
    Agradecido 437 veces en 275 posts
    Mencionado
    32 Post(s)
    Tagged
    0 Tema(s)
    Entradas de blog
    7
    Cita Iniciado por zhorro Ver mensaje
    Cabrito, esos chistes no se dicen sin avisar que casi me atraganto con la coca cola... toda la programación con C# ... juarfs juarfs juarfs...
    Me refería a programación de aplicaciones web, .NET y toda esa pesca, hombre. Pero lo comprendo, no lo dejé del todo claro en mi anterior post.
    _
    .

  6. #20
    Fecha de ingreso
    Jan 2008
    Ubicación
    Madrid
    Mensajes
    4,416
    Agradecer
    51
    Agradecido 112 veces en 67 posts
    Mencionado
    12 Post(s)
    Tagged
    0 Tema(s)
    Cuando pasas un puntero a un array a una función en C, es mejor pasar el tamaño como entero, porque es más seguro y no se puede saber el tamaño en la función. Recuerda que un puntero a un array es la dirección de su primer elemento. Es decir, algo parecido a esto:

    Código:
    int sumar(int *array, int size)
    {
         //....
    }
    Y se llamará así, aquí puedes hacer sizeof porque el llamador conoce el array:
    Código:
    int total = sumar(array, sizeof(array) / sizeof(int));
    P.D. Ahora que lo veo, lo he hecho de forma parecida a SplinterGU, pero sin estructuras, más manual. Con su solución lo tienes todo más ordenado, cada array con su tamaño como si fuera un objeto.
    Última edición por hardyx; 16/06/2017 a las 21:26

  7. #21
    Fecha de ingreso
    Jun 2017
    Mensajes
    2
    Agradecer
    0
    Agradecido 0 veces en 0 posts
    Mencionado
    1 Post(s)
    Tagged
    0 Tema(s)
    Hola

    Lo que intento hacer es implementar un algoritmo eficiente para multiplicar dos numero grandes, de unas 200 cifras cada uno.
    El algoritmo de basa en ir dividiendo los números en mitades hasta que queden unas mitades con valores abordables, y esto se realiza mediante recursividad.
    Una especie de algoritmo de Karatsuba.

    Y efectivamente, estoy viendo que la única manera es pasando el tamaño de las matrices.

    La primera vez, desde la función main() se llamaría de la siguiente forma
    multiply(a, (unsigned short)(sizeof(a)/sizeof(unsigned short)), b, (unsigned short)(sizeof(b)/sizeof(unsigned short)));

    y en la función

    void multiply(unsigned short *a, unsigned short x, unsigned short *b, unsigned short y)
    {
    unsigned short lMaxima = (x > y) ? x : y;
    unsigned short lDcha = lMaxima/2;
    unsigned short lIzda = lMaxima - lDcha;
    ...
    ...
    unsigned short x0[lIzda]; for (int i = 0; i < lIzda; i++) x0[i]=0;
    unsigned short x1[lDcha]; for (int i = 0; i < lDcha; i++) x1[i]=0;
    unsigned short y0[lIzda]; for (int i = 0; i < lIzda; i++) y0[i]=0;
    unsigned short y1[lDcha]; for (int i = 0; i < lDcha; i++) y1[i]=0;
    ...
    ...
    ...
    ...

    x0y0 = multiply(x0, lIzda, y0, lIzda);
    x1y1 = multiply(x1, lDcha, y1, lDcha);

    }

    Muchas gracias por la ayuda

  8. #22
    Fecha de ingreso
    Jul 2009
    Mensajes
    8,264
    Agradecer
    664
    Agradecido 290 veces en 222 posts
    Mencionado
    48 Post(s)
    Tagged
    0 Tema(s)
    Cita Iniciado por hardyx Ver mensaje
    Cuando pasas un puntero a un array a una función en C, es mejor pasar el tamaño como entero, porque es más seguro y no se puede saber el tamaño en la función. Recuerda que un puntero a un array es la dirección de su primer elemento. Es decir, algo parecido a esto:

    Código:
    int sumar(int *array, int size)
    {
         //....
    }
    Y se llamará así, aquí puedes hacer sizeof porque el llamador conoce el array:
    Código:
    int total = sumar(array, sizeof(array) / sizeof(int));
    P.D. Ahora que lo veo, lo he hecho de forma parecida a SplinterGU, pero sin estructuras, más manual. Con su solución lo tienes todo más ordenado, cada array con su tamaño como si fuera un objeto.
    es correcto, como lo puse en mi primer respuesta

    Cita Iniciado por SplinterGU Ver mensaje
    porque lo que recibe multiply como parametro son punteros no una matriz/array...

    el compilador ya te lo esta diciendo

    array.c: In function ‘multiply’:
    array.c:4:45: warning: ‘sizeof’ on array function parameter ‘a’ will return size of ‘int *’ [-Wsizeof-array-argument]
    printf("\nTamaño de a = %d\n", (int)(sizeof(a)/sizeof(int)));


    -----Actualizado-----

    tienes que incluir el tamaño como parametro... algo asi


    void multiply(int a[], int sza, int b[], int szb)

    ....


    multiply(a,sizeof(a)/sizeof(int),b,sizeof(b)/sizeof(int))




    (aunque yo usaria sizeof(a[0]) en lugar de sizeof(int))
    -----Actualizado-----

    Cita Iniciado por AJMurphy Ver mensaje
    Hola

    Lo que intento hacer es implementar un algoritmo eficiente para multiplicar dos numero grandes, de unas 200 cifras cada uno.
    El algoritmo de basa en ir dividiendo los números en mitades hasta que queden unas mitades con valores abordables, y esto se realiza mediante recursividad.
    Una especie de algoritmo de Karatsuba.

    Y efectivamente, estoy viendo que la única manera es pasando el tamaño de las matrices.

    La primera vez, desde la función main() se llamaría de la siguiente forma
    multiply(a, (unsigned short)(sizeof(a)/sizeof(unsigned short)), b, (unsigned short)(sizeof(b)/sizeof(unsigned short)));

    y en la función

    void multiply(unsigned short *a, unsigned short x, unsigned short *b, unsigned short y)
    {
    unsigned short lMaxima = (x > y) ? x : y;
    unsigned short lDcha = lMaxima/2;
    unsigned short lIzda = lMaxima - lDcha;
    ...
    ...
    unsigned short x0[lIzda]; for (int i = 0; i < lIzda; i++) x0[i]=0;
    unsigned short x1[lDcha]; for (int i = 0; i < lDcha; i++) x1[i]=0;
    unsigned short y0[lIzda]; for (int i = 0; i < lIzda; i++) y0[i]=0;
    unsigned short y1[lDcha]; for (int i = 0; i < lDcha; i++) y1[i]=0;
    ...
    ...
    ...
    ...

    x0y0 = multiply(x0, lIzda, y0, lIzda);
    x1y1 = multiply(x1, lDcha, y1, lDcha);

    }

    Muchas gracias por la ayuda
    de nada
    ...

  9. #23
    Fecha de ingreso
    Jan 2007
    Ubicación
    Ciudad Catedral, Reino de Dick
    Mensajes
    3,570
    Agradecer
    78
    Agradecido 70 veces en 54 posts
    Mencionado
    7 Post(s)
    Tagged
    0 Tema(s)
    También puede usarse lo que yo llamo el "modo Pascal implementado en C", que consiste en usar el primer elemento de la lista para contener el tamaño de la misma (razón por la que en los Pascal los STRING empiezan en el 1 y no en el 0, y son como máximo de 255 caracteres).

    Y decir que C está caduco... Madredelamorhermosa...
    Proyectos actuales ----> Bufff..
    Entorno de desarrollo ----> Bufff...

  10. #24
    Fecha de ingreso
    Oct 2007
    Ubicación
    Madrid
    Mensajes
    2,013
    Agradecer
    96
    Agradecido 123 veces en 84 posts
    Mencionado
    49 Post(s)
    Tagged
    0 Tema(s)
    Cita Iniciado por akualung Ver mensaje
    Hombre, yo me refiero a los que programan en visual studio. O usas VB o C#. Si haces juegos o otras cosas que se salga del habitual desarrollo de aplicaciones web, entonces sí.
    Quizá no sea tan habitual el desarrollo de aplicaciones web, quizá haya un "pelotón" de personas que programan, sí, pero otras cosas... y no son pocos precisamente.

    Otra cosa es que no se conozcan esos campos de trabajo, pero están ahí y no son raros ni bizarros; todo el campo de la mecatrónica (automóviles, aviones, trenes, electrodomésticos, internet de las cosas...) por no ir más lejos, es C y con suerte los elementos de más bajo nivel estarán integrados en Simulink y/o LabView, con lo que la parte más difícil de algoritmia la podrás programar de una forma mucho más sencilla y abstracta.
    La maestría interior...

Página 2 de 2 PrimerPrimer 12

Permisos de publicación

  • No puedes crear nuevos temas
  • No puedes responder temas
  • No puedes subir archivos adjuntos
  • No puedes editar tus mensajes
  •