El "sizeof" para saber el tamaño del arreglo no me funciona

[RGT]

Código:

int liContador, laiArreglo[] = {5,8,2,3,1,4,6,9,2,10};

    printf("\nCONJUNTO: ");

    for (liContador = 0; liContador < sizeof (laiArreglo) / sizeof (int); liContador++)
    {
        printf("%d ", laiArreglo[liContador]);
    }

Con ese código solamente me muestra el 5.

Anteriormente tenía laiArreglo[10] y me funcionaba correctamente. Al hacer esto laiArreglo[] = {5,8,2,3,1,4,6,9,2,10}, ya me dejo de funcionar. El FOR solo llega hasta 1 y no hasta 10.

Por qué?.

[razpeitia]

A mi si me imprime todos

Código C:

#include<stdio.h>
 
int main() {
 
int liContador, laiArreglo[] = {5,8,2,3,1,4,6,9,2,10};
 
    printf("\nCONJUNTO: ");
 
    for (liContador = 0; liContador < sizeof (laiArreglo) / sizeof (int); liContador++)
    {
        printf("%d ", laiArreglo[liContador]);
    }
    return 0;
}
 

[vangodp]

Tampoco no le veo nada malo :S

[ecfisa]

Hola RGT.

Así, tál como lo mostras, no concibo que no te funcione. Pero si no me equivoco, estas haciendo algo como esto:

Código C:

...
void mostrar ( int *v ) {
  int i;
  for ( i = 0; i < sizeof(v) / sizeof(int); i++ )
    printf ( "%d ", v[i] );
}
 
int main ( ) {
  int v[10] = {5, 8, 2, 3, 1, 4, 6, 9, 2, 10};
  mostrar ( v );
  ...
 

de ese modo sí que entiendo el comportamiento que comentas... Por que,

Código:

sizeof ( v ) = 4 y sizeof ( int ) = 4

entonces:
sizeof ( v ) / sizeof ( int ) = 1

por lo que:
for ( i = 0; i < 1 ; i++) -> i = 0

de ese modo, sólo se muestra el valor de v[0] que es 5.

Deberías hacer algo similar a esto:

Código C:

...
void mostrar ( int* v, int sz ) {
  int i;
  for ( i = 0; i < sz; i++ )
    printf ( "%d ", v[i] );
}
 
int main ( ) {
  int v[10] = {5,8,2,3,1,4,6,9,2,10};
  mostrar ( v, sizeof(v) / sizeof(int) );
 

Saludos.

[RGT]

Hola,
Realmente tengo esto:

Código:

int liOpcionMenu, laiArreglo[] = {5,8,2,3,1,4,6,9,2,10}, liElemento;

printf("\nIngrese el elemento: ");
            scanf("%d", &liElemento);
            EliminarElemento(liElemento, laiArreglo);   //Llamamos a la función
            MostrarConjunto(laiArreglo);                //Mostramos el arreglo





void MostrarConjunto(int laiArreglo[])
{
    int liContador;

    printf("\nCONJUNTO: ");

    for (liContador = 0; liContador < sizeof (laiArreglo) / sizeof (int); liContador++)
    {
        printf("%d ", laiArreglo[liContador]);
    }
}

el sizeof no funciona dentro de funciones, eso es?.

[dehm]

Cuando pasas un array como parámetro, en realidad estás pasando un puntero al primer elemento del array.

Por eso, el ejemplo que te ha puesto ecfisa es igual a lo que tú tienes, y por tanto el comportamiento es el mismo y la explicación de ecfisa es la correcta.

Mira aquí:
http://c.conclase.net/curso/index.ph...UN2_ArrayParam

[RGT]

Ya lo leí y ahora entendi mejor pero,
No entendi el ejemplo de ella, que fue lo que hizo?..

[dehm]

Iniciado por RGT

Ya lo leí y ahora entendi mejor pero,
No entendi el ejemplo de ella, que fue lo que hizo?..

En el enlace que te he puesto queda explicado.

Bueno, al entender que el pasar un array como parámetro es equivalente a pasar un puntero al primer elemento del array, ecfisa ha supuesto que estabas haciendo esto último (que en todo caso es realmente lo mismo).

Y como esa dirección de memoria no te da información del tamaño total del array, lo suyo es que estas funciones se usen con dos parámetros, uno el propio array (o puntero al primer elemento) y otro el tamaño del array, puesto que una vez dentro de la función no se podrá averiguar.

Edito:

Sin embargo, si defines el array con su tamaño en la función si podrás saber dicho tamaño dentro de la función, pero la función será poco operativa (solo valdrá para arrays con el tamaño indicado por la función).

Te pongo un ejemplo de tres formas de enfocar la función:
1.- Pasando como parámetro a la función un array con tamaño definido (sencillo pero poco funcional)
2.- Pasando como parámetro a la función un array sin tamaño predefinido y un valor que indique el tamaño del array.
3.- Pasando como parámetro un puntero y el tamaño del array.

Código C++:

#include <iostream>
 
using namespace std;
 
void mostrar (int array[], int tam);
void mostrar2 (int array[5]);
void mostrar3 (int* punt, int tam);
 
int main()
{
 
    int v[]={10,20,30,40,50};
 
    mostrar (v, sizeof(v)/sizeof(int));
    mostrar2(v);
    mostrar3(v,sizeof(v)/sizeof(int));
 
    return 0;
}
 
void mostrar (int array[], int tam)
{
    for (int i=0;i<tam;i++)
    {
        cout<<array[i]<<"-";
    }
    cout<<endl;
}
 
void mostrar2 (int array[5])
{
    for (int i=0;i<=sizeof(array[5]);i++)
    {
        cout<<array[i]<<"-";
    }
    cout<<endl;
}
 
void mostrar3 (int* punt, int tam)
{
    for (int i=0;i<tam;i++)
    {
        cout<<*(punt+i)<<"-";
    }
    cout<<endl;
}
 

Espero que esto te ayude

[RGT]

ok, a ver si entendí.

Tenemos esto:
mostrar ( Arreglo, sizeof(Arreglo) / sizeof(int) );

void mostrar (int Arreglo, int TamanoArreglo)
{
............
}

Estaremos pasando:
El arreglo obvio y de segundo el tamaño del arreglo (ejemplo: 10) para de esa forma no tener que buscar el tamaño dentro de la función.
Correcto?.
(Excusame, aprendo lento y me gusta aprender correctamente toda la logica.)

Respecto a los ejemplos que me diste:

1.- Pasando como parámetro a la función un array con tamaño definido (sencillo pero poco funcional)
Me gusto, es la más fácil creo. No es recomendable que use esta entonces?.

2.- Pasando como parámetro a la función un array sin tamaño predefinido y un valor que indique el tamaño del array.
Esto funciona para cualquier manera que inicialize el arreglo?.

Ejemplo:
Arreglo[6]
Arreglo[] = {1,2,5,6,4,1}

void mostrar2 (int array[6]) //Considero esto poco funcional ya que tendría que cambiar el valor adentro de los [] cada vez que quiera un arreglo de tamaño diferente.

3.- Pasando como parámetro un puntero y el tamaño del array.

Para qué sirve el *?, no sé usar punteros todavía.
:(


Gracias por toda tu explicacion hermano, me ayudas muchisimo, espero que no te moleste...

[ecfisa]

Hola RGT.

La explicación y ejemplos que te ha puesto dehm han sido mas que claros, solo agregar que un modo que la función reciba la información necesaria en un solo parámetro puede ser:

Código C++:

#include <stdio.h>
 
typedef struct {
  int *sv;
  int sz;
} stArray;
 
void mostrar (stArray v) {
  int i;
  for ( i = 0; i < v.sz; i++ )
    printf ( "%d ", v.sv[i] );
}
 
int main() {
  int vv[10] = {5, 8, 2, 3, 1, 4, 6, 9, 2, 10};
  stArray stv;
 
  stv.sv = vv;
  stv.sz = sizeof(vv) / sizeof(vv[0]);
  mostrar(stv);
  ...
 

pero en definitiva los datos enviados siguen siendo dos...

Para qué sirve el *?, no sé usar punteros todavía.

En este enlace vas a encontrar un buen tratamiento sobre el tema.

Saludos.

[RGT]

Iniciado por ecfisa

Hola RGT.

La explicación y ejemplos que te ha puesto dehm han sido mas que claros, solo agregar que un modo que la función reciba la información necesaria en un solo parámetro puede ser:

Código C++:

#include <stdio.h>
 
typedef struct {
  int *sv;
  int sz;
} stArray;
 
void mostrar (stArray v) {
  int i;
  for ( i = 0; i < v.sz; i++ )
    printf ( "%d ", v.sv[i] );
}
 
int main() {
  int vv[10] = {5, 8, 2, 3, 1, 4, 6, 9, 2, 10};
  stArray stv;
 
  stv.sv = vv;
  stv.sz = sizeof(vv) / sizeof(vv[0]);
  mostrar(stv);
  ...
 

pero en definitiva los datos enviados siguen siendo dos...


En este enlace vas a encontrar un buen tratamiento sobre el tema.

Saludos.

Hola,
no entiendo bien tus ejemplos :(
usas diferentes variables y cosas raras ej:
stv.sz
sv
sz
starray v
v.sz
v.sv

me estoy volviendo loco tratando de entender ahahahhaa

[dehm]

Bueno, si no has empezado a ver punteros y estructuras, mejor olvida esa parte.
Simplemente quédate con la idea:

Al pasar un array como parámetro de una función, sólo se pasa la dirección del primer elemento del array. Con esa información, la función no tiene forma de saber el tamaño del array, por lo que le debes de suministrar ese dato de forma expresa como otro parámetro.

[RGT]

Iniciado por dehm

Bueno, si no has empezado a ver punteros y estructuras, mejor olvida esa parte.
Simplemente quédate con la idea:

Al pasar un array como parámetro de una función, sólo se pasa la dirección del primer elemento del array. Con esa información, la función no tiene forma de saber el tamaño del array, por lo que le debes de suministrar ese dato de forma expresa como otro parámetro.

Hola,

Ejemplo:

Código:

int Arreglo[] = {2,5,4,8,2};

mostrar ( Arreglo, sizeof(Arreglo) / sizeof(int) );

void mostrar (int Arreglo[], int TamanoArreglo)
{
............
}

entonces TamanoArreglo sería igual a 5, cierto?. esta es la idea?, puedo usarlo de esta forma?.

[dehm]

Eso es!

[ecfisa]

no entiendo bien tus ejemplos :(
usas diferentes variables y cosas raras ej:
stv.sz
sv
...
me estoy volviendo loco tratando de entender ahahahha

Te pido disculpas, soy medio haragán para escribir.

Espero que quede mas entendible de este modo:

Código C:

#include <stdio.h>
 
typedef struct {
  int *array;  // arreglo
  int size;    // tamaño
} stArray;
 
void mostrar (stArray sa) {
  int i;
  for ( i = 0; i < sa.size; i++ )
    printf ( "%d ", sa.array[i] );
}
 
int main() {
  int array10[10] = {5, 8, 2, 3, 1, 4, 6, 9, 2, 10};
  stArray sArray;
 
  sArray.array = array10;
  sArray.size  = sizeof(array10) / sizeof(array10[0]);
  mostrar(sArray);
 
  getchar();
  return 0;
}
 

entonces TamanoArreglo sería igual a 5, cierto?. esta es la idea?, puedo usarlo de esta forma?.

A ver, cuando declaras:

Código C++:

int Arreglo[] = {2,5,4,8,2};
 

Así es, "Arreglo" tiene cinco elementos a los cuales accedes mediante los índices 0 a 4 (Arreglo[0], ..., Arreglo[4])

Si "Arreglo" está declarado "por encima" de la función,

Código C:

#include <stdio.h>
 
int Arreglo[] =  {2,5,4,8,2};
 
void mostrar (...
 

la función lo conoce (es del ámbito), por lo que podes usar sin problemas: sizeof(Arreglo) / sizeof(int). Es mas, hasta podes omitir enviar el arreglo como parámetro:

Código C:

#include <stdio.h>
 
int Arreglo[] =  {2,5,4,8,2};
 
void mostrar ( void ) {
  int i;
  for ( i = 0; i < sizeof(Arreglo) / sizeof(int); i++ )
  ...
}
 

En cambio cuando está declarado fuera del ámbito de la función, como en este caso:

Código C:

#include <stdio.h>
 
void mostrar (int *arreglo, int tamanio) {
  int i;
  for ( i = 0; i < tamanio; i++ )
    printf ( "%d ", arreglo[i] );
}
 
int main() {
  int Arreglo[] = {2,5,4,8,2};
  mostrar(Arreglo, sizeof(Arreglo)/sizeof(Arreglo[0]));
  ...
 

Debes enviar su tamaño o especificarlo explícitamente. Las formas en que podes declarar los parámetros para pasar el arreglo, te lo mostró dehm en el código del mensaje #8

Si no fuí claro en algún punto por favor decime e intento explicarlo de otro modo.

Saludos.

[RGT]

Iniciado por ecfisa

Te pido disculpas, soy medio haragán para escribir.

Espero que quede mas entendible de este modo:

Código C:

#include <stdio.h>
 
typedef struct {
  int *array;  // arreglo
  int size;    // tamaño
} stArray;
 
void mostrar (stArray sa) {
  int i;
  for ( i = 0; i < sa.size; i++ )
    printf ( "%d ", sa.array[i] );
}
 
int main() {
  int array10[10] = {5, 8, 2, 3, 1, 4, 6, 9, 2, 10};
  stArray sArray;
 
  sArray.array = array10;
  sArray.size  = sizeof(array10) / sizeof(array10[0]);
  mostrar(sArray);
 
  getchar();
  return 0;
}
 

A ver, cuando declaras:

Código C++:

int Arreglo[] = {2,5,4,8,2};
 

Así es, "Arreglo" tiene cinco elementos a los cuales accedes mediante los índices 0 a 4 (Arreglo[0], ..., Arreglo[4])

Si "Arreglo" está declarado "por encima" de la función,

Código C:

#include <stdio.h>
 
int Arreglo[] =  {2,5,4,8,2};
 
void mostrar (...
 

la función lo conoce (es del ámbito), por lo que podes usar sin problemas: sizeof(Arreglo) / sizeof(int). Es mas, hasta podes omitir enviar el arreglo como parámetro:

Código C:

#include <stdio.h>
 
int Arreglo[] =  {2,5,4,8,2};
 
void mostrar ( void ) {
  int i;
  for ( i = 0; i < sizeof(Arreglo) / sizeof(int); i++ )
  ...
}
 

En cambio cuando está declarado fuera del ámbito de la función, como en este caso:

Código C:

#include <stdio.h>
 
void mostrar (int *arreglo, int tamanio) {
  int i;
  for ( i = 0; i < tamanio; i++ )
    printf ( "%d ", arreglo[i] );
}
 
int main() {
  int Arreglo[] = {2,5,4,8,2};
  mostrar(Arreglo, sizeof(Arreglo)/sizeof(Arreglo[0]));
  ...
 

Debes enviar su tamaño o especificarlo explícitamente. Las formas en que podes declarar los parámetros para pasar el arreglo, te lo mostró dehm en el código del mensaje #8

Si no fuí claro en algún punto por favor decime e intento explicarlo de otro modo.

Saludos.

Hola, gracias por la explicación.

Tenía las funciones abajo del MAIN y no me funcionaba como dices, tuve que enviar el tamaño en otro argumento con los métodos que me han enseñado.

Otra cosa que leí es que debería usar size_t para guardar tamaños usando sizeof.

Ejemplo;

Código:

funcion(Arreglo, sizeof (Arreglo) / sizeof (int);

void funcion(int Arreglo[], size_t TamanoArreglo)
{
{

es correcto esto?.
y también es cierto que haciendo eso no tendría que enviar el Arreglo a la función?

Ejemplo:

Código:

funcion(sizeof (Arreglo) / sizeof (int);

void funcion(size_t TamanoArreglo)
{
podría usar el Arreglo normalmente y TamanoArreglo también....
{

[vangodp]

size_t es un entero sin signo, o sea unsigned int que puede variar de un compilador a otro ya que algunos pueden ser long etc etc. Pero básicamente se trata de una variable que no puede guardar números negativos ya que un array no debería tener numeros negativos como array[-10] (Eso seria un disparate XD).

size_t es un typedef de un entero sin signo que puede variar de un compilador a otro.

[RGT]

Iniciado por vangodp

size_t es un entero sin signo, o sea unsigned int que puede variar de un compilador a otro ya que algunos pueden ser long etc etc. Pero básicamente se trata de una variable que no puede guardar números negativos ya que un array no debería tener numeros negativos como array[-10] (Eso seria un disparate XD).

size_t es un typedef de un entero sin signo que puede variar de un compilador a otro.

Hola, gracias por tu respuesta.
O sea, no es necesario el uso de size_t?, con el uso de int, también es válido?.