C ++ Sizeof
Sintaxe do operador sizeof () em C++
A seguir, descreve a sintaxe do operador sizeof ():
# sizeof (nome de data_type);Quando usado com o primeiro tipo de objeto, a função sizeof () gera o tamanho do objeto em bytes para o tipo de objeto que está sendo enviado. O tamanho do item que está no tipo de expressão, medido em bytes, é o segundo tipo. Depois que a expressão é avaliada, o tamanho permanece o mesmo.
Exemplo 1:
Quando os tipos de dados como int, float, char, etc. são usados com o operador sizeof (), a função apenas fornece a quantidade de RAM que é atribuída a esse tipo de dados específico.
#incluirusando namespace std;
int main ()
std :: cout << "Size of data type int : " <
Ao utilizar o operador sizeof () com o comando cout, avaliamos o tamanho dos tipos de dados internos no aplicativo acima mencionado. Como podemos ver na saída a seguir, a operação sizeof () produz a mesma resposta que esperaríamos, dado o nosso conhecimento dos tamanhos de bytes de Int, Float, Double e Char.
Exemplo 2:
O programa, quando um tipo de classe é operando, usa o operador sizeof (). Aqui está uma ilustração:
#incluirusando namespace std;
classe mybase_class
int x;
;
int main ()
Mybase_class y;
std :: cout << "Size of Base class is : "<
Com apenas uma variável inteira "x" na classe "mybase_class" e no método principal do script acima mencionado, avaliamos o tamanho da classe. Primeiro, chamamos a classe dada e criamos seu objeto como "y". Em seguida, temos um operador sizeof () que toma "y" como uma entrada. As variáveis inteiras ocupam 4 bytes, portanto o resultado seria de 4 bytes, conforme impresso no seguinte:
Exemplo 3:
Se aumentarmos o número de variáveis inteiras em uma classe, o código a seguir será produzido:
#incluirusando namespace std;
classe myclass_base
int i;
int j;
;
int main ()
Myclass_base j;
std :: cout << "Size of MyClass_Base is : "<
Agora existe uma segunda variável inteira "j" no código anterior. Dado que a variável int ocupa 4 bytes e há duas variáveis inteiras como "i" e "j", a classe "myclass_base" neste cenário é 8 bytes em tamanho.
Exemplo 4:
O código pode se parecer com o seguinte se incluirmos uma variável de char:
#incluirusando namespace std;
classe myclass
int p;
int q;
char ch;
;
int main ()
Myclass q;
std :: cout << "Size of MyClass is : "<
Dois inteiros e uma variável de char são usados no código anterior da classe “MyClass”. O tamanho da classe deve ser 9 bytes, pois existem três tipos de dados (int+int+char) de acordo com nossos cálculos. Mas isso está incorreto por causa da idéia de estofamento de estrutura. Você pode ver o seguinte valor de resultado:
Exemplo 5:
O caso em que o operando é uma matriz. Vamos dar uma olhada na implementação do programa:
#incluirusando namespace std;
int main ()
int ar_set [] = 5,15,25,35,45;
std :: cout << "Size of the 'arr_set' is : "<
Estabelecemos uma matriz do tipo inteiro como "arr_set" com cinco elementos no programa anterior. Determinamos o tamanho da matriz usando o operador sizeof (). A matriz tem 20 bytes de tamanho, pois o tipo de dados int ocupa 4 bytes e existem 5 entradas na matriz, fazendo um espaço total de memória precisando de 5 * 4 = 20 bytes. Como podemos ver na saída a seguir, a operação sizeof () produziu o mesmo resultado.
Exemplo 6:
O exemplo já leva o tamanho da matriz. Vamos considerar uma matriz de uma perspectiva específica.
#incluirusando namespace std;
void new_function (int matriz [])
std :: cout << "Size of array is : " <
int main ()
int array [] = 51,52,53,54,55;
new_function (matriz);
retornar 0;
Tentamos utilizar a função "New_function" no aplicativo acima mencionado para imprimir o tamanho da matriz. Formamos uma matriz do tipo inteiro nesse caso e enviamos o parâmetro "Array" para o new_function (). O tamanho do ponteiro inteiro ou int* é retornado pela new_function (). Nos sistemas operacionais de 64 bits, o tamanho do int* é 8 bytes. A saída gera o tamanho da matriz da seguinte maneira:
Exemplo 7:
Agora, este é o exemplo em que o argumento é do tipo de ponteiro dentro do operador sizeof ().
#incluirusando namespace std;
int main ()
int *ptr1 = new int (31);
std :: cout << "ptr1 size:" <
std :: cout <<"ptr2 size :" <
std :: cout <<"ptr3 size :" <
Calculamos o tamanho dos ponteiros no script mencionado no anterior. Para os tipos de dados "int", "duplo" e "char", os tamanhos do ponteiro permanecem constantes. O tamanho do ponteiro é de 4 bytes se o computador tivesse um sistema operacional de 32 bits. O tamanho do ponteiro é de 8 bytes se o computador executar um sistema operacional de 64 bits. O resultado é 8 bytes, pois executamos este script em uma plataforma de 64 bits. Agora, se dermos ao ponteiro o símbolo "*", a saída muda dependendo do tipo de dados. Por exemplo, se *ptr1 for do tipo inteiro, o operador sizeof () fornece 4 bytes porque um tipo de dados int ocupa 4 bytes. A seguir, é apresentado o tamanho resultante dos ponteiros correspondentes a cada tipo de dados especificado:
Exemplo 8:
O exemplo em que temos uma expressão como um operador de tamanho (operando).
#incluirusando namespace std;
int main ()
int Integer_1;
duplo integer_2;
cout << "size of int and double: " <
Temos duas variáveis, Integer_1 e Integer_2, dos tipos int e duplos, respectivamente. Eles são declarados no programa. Como sabemos, os números inteiros têm 4 bytes de tamanho, enquanto duplas são 8 bytes. Adicionamos os dois no operador sizeof (). A variável, dupla com um tamanho de 8 bytes, é o resultado.
Conclusão
Uma explicação sizeof () para C ++ termina aqui. Passamos os detalhes sobre como o operador C ++ Sizeof () opera, juntamente com exemplos relevantes. Qualquer tipo de dados, expressão, matriz, etc. pode ter seu tamanho determinado usando o operador sizeof (). O tipo de dados ou uma expressão deve ser fornecida como parte do argumento. E a função retorna o tamanho desse tipo de dados em bytes como resultado.