Função sizeof [RESOLVIDO]

1. Função sizeof [RESOLVIDO]

alanp1
(usa Outra)

Enviado em 24/07/2020 - 21:34h

Pessoal, preciso fazer uma função que calcular a quantidade de posições de um vetor enviado por parâmetro. Entretanto quando crio essa função ela calcula e mostra apenas metade das posições(utilizo a função sizeof).
E quando executo a função sizeof na função main retorna a quantidade correta.
Como posso resolver isso?

Segue o código:



#include <stdio.h>





void tamanho(int *vetor0){



	int tamanho=sizeof(vetor0)/sizeof(int);

	printf("%d",tamanho);//printa na tela o valor 2 referente a metade das posicoes



}



int main(){

	int vetor[4]={8,9,9,4};

	int tan;



	tan=sizeof(vetor)/sizeof(int);

	printf("%d\n",tan);//Da um print do valor 4, o valor correto das posicoes

	tamanho(vetor);

}

0 0

Quote

2. MELHOR RESPOSTA

paulo1205
(usa Ubuntu)

Enviado em 25/07/2020 - 11:21h

Bom dia, prezado.

Note que sizeof não é uma função, mas sim um operador.

Se A tiver sido declarado como um array com elementos de um tipo qualquer, a forma usual de calcular o número de elementos é fazer o seguinte.

sizeof A/sizeof A[0]

Como o C não permite passar arrays como parâmetros de função, dado que eles decaem para ponteiros automaticamente (exceto justamente quando usados como operandos de sizeof ou de &), você não pode fazer uma função que calcule o número de elementos. Se tentar fazê-lo da forma usual (i.e. recebendo um ponteiro), você vai acabar calculando quantas vezes o tamanho do ponteiro é maior do que o tamanho do elemento, o que pode inclusive provocar tamanho zero.

/*** ATENÇÃO: ESTAS IMPLEMENTAÇÕES ESTÃO ERRADAS.  NÃO USE! ***/

#include <stdio.h>



struct big_struct {

    uint64_t many_elements[10000];  // 10 mil elementos com de 8 bytes, totalizando 80 mil bytes.

};



struct big_struct big_array[10000];  // 10 mil elementos de 80 mil bytes, com tamanho total de 800 milhões de bytes.



size_t bad_big_struct_array_size(struct big_struct *p){

    return sizeof pi/sizeof *pi;  // Certamente vai retornar 0, porque sizeof de ponteiro deve ser 4 ou 8 bytes, que, divididos por 80 mil, dá zero.

}



int main(){

    printf("%zu\n", szieof big_struct_array/sizeof big_struct_array[0]);  // Vai imprimir 10000.  OK.

    printf("%zu\n", bad_big_struct_array_size(big_struct_array));  // Vai imprimir 0.  Ruim, mas “correto”, de acordo com as regras da linguagem.

}

A alternativa para fazer em C é através de macros. Como as macros expandem o código dentro do local onde elas são usadas, a construção “sizeof x/sizeof x[0]” pode aparecer como consequência da expansão in loco, desde que de tomem certos cuidados.

// Os parênteses são necessários para evitar alguns problemas quando “x” tem formas compostas, como “a+n” ou “(a, b)”.

#define better_array_size(x) (sizeof (x)/sizeof (x)[0])

Note que o exemplo acima não evita certos erros, tais como chamar a macro com um ponteiro, em vez de com um array, dá margem a comportamentos estranhos com efeitos colaterais ao expandir x duas vezes, e é sujeita a erros de compilação relativamente difíceis de depurar quando o argumento não é nem um array nem um ponteiro.

Se você estiver usando C++, o uso de templates ajuda a eliminar erros que ocorrem com macros.

template <typename T, size_t N> constexpr size_t array_size(const T(&)[N]){ return N; }

Essa função tem todas as vantagens da forma anterior com macros, mas não tem os defeitos de poder ser chamada com ponteiro em vez de array, não está sujeita a efeitos colaterais, já que não há expansão de macro, nem tem problema com expressões compostas.

... Então Jesus afirmou de novo: “(...) eu vim para que tenham vida, e a tenham plenamente.” (João 10:7-10)

0 0

Quote