Explicação detalhada das palavras-chave da linguagem C (3) Tipo de dados e tamanho da palavra-chave

I. Introdução

Olá a todos, bem-vindos à coluna de análise detalhada da linguagem C - a terceira parte da explicação detalhada da palavra-chave da linguagem C. Neste artigo, apresentaremos os tipos de dados na linguagem C e, assim, levaremos a outra palavra-chave importante na linguagem C idioma. — sizeof .

Em segundo lugar, o tipo de dados

1. Quais são os tipos de dados

Os tipos de dados na linguagem C incluem tipos primitivos (tipos internos), tipos construídos (tipos personalizados), tipos de ponteiro e tipos nulos

2. Por que precisamos de tipos de dados?

Por que ter tipos integrados

Encontramos vários cenários em nossa vida diária, e cenários diferentes exigem dados diferentes para representar, como o número de pessoas que jantamos, a temperatura do clima, a altitude e outras coisas geralmente são descritas por números inteiros, como a altura de um pessoa , a frequência de transmissão e o preço das mercadorias são geralmente expressos em decimais. Por exemplo, o número da nossa placa, o nome do edifício e o tamanho da roupa precisam ser expressos em letras; linguagem C, como o primeiro linguagem de programação de alto nível, para poder descrever com precisão vários cenários em nossas vidas, existem tipos internos, como inteiros, tipos de ponto flutuante e tipos de caracteres.

Por que ter tipos personalizados

Tomemos como exemplo o tipo de matriz e o tipo de estrutura no tipo personalizado:
Tipo de matriz: encontraremos muitos conjuntos do mesmo tipo em nossa vida, como o número de aluno de um aluno da escola e o número de aluno de cada aluno é um inteiro, então para representar o número de alunos de todos os alunos, é necessário definir milhares de inteiros. Obviamente, isso é muito problemático, então um tipo de array é gerado. O tipo de cada elemento em um array é o mesmo Estamos definindo um aluno da escola Quando você é um aluno, você só precisa definir um array com um tamanho de vários milhares de elementos, em vez de definir lentamente mil
tipos de estrutura inteira: os objetos que queremos descrever em nossas vidas geralmente são coleções de tipos de dados complexos. Por exemplo, uma pessoa tem nome, sexo, altura, peso, idade, etc. Esses tipos de dados são todos diferentes, portanto, para descrever sistematicamente os atributos de uma pessoa, é gerado um tipo de estrutura, que converte uma pessoa para diferentes tipos.Todos os dados são centralizados em um novo tipo, o que torna a descrição e o uso do objeto mais convenientes.

3. Como tratar os tipos de dados

Do blog anterior, sabemos que a essência de definir variáveis ​​é abrir um espaço na memória para armazenar dados, e hoje sabemos que diferentes variáveis ​​precisam ser definidas como tipos diferentes. sai: o tipo determina o tamanho do espaço aberto pela variável.
Neste momento, há duas perguntas: primeiro, por que devemos abrir espaço de acordo com o tipo? Podemos abrir um espaço diretamente e usar a memória como um todo, certo? A resposta é: não é bom.
Existem duas razões principais:
1. A qualquer momento, seu computador não está executando apenas o programa que você está usando no momento, existem muitos outros programas sendo executados ao mesmo tempo, se o bloco inteiro estiver alocado para o programa em execução no momento, outros programas colidir.
2. Mesmo que todo o bloco de memória seja alocado a você, você não pode garantir que o bloco de memória será usado a qualquer momento, o que levará a um desperdício de memória.
Segundo, usamos parte da memória, quanto é usado por quê? A resposta é: é determinado pelo seu cenário, seu cenário de cálculo e que tipo de variáveis ​​você usa para o cálculo. O tipo que você usa determina quantos bytes de espaço você abre. É por isso que a linguagem C possui tantos tipos de dados, apenas para atender a diferentes cenários de computação.
Finalmente, quanto espaço os diferentes tipos de dados abrem na memória? Isso precisa ser calculado usando nossa palavra-chave – sizeof.

Três, sizeof - Calcula o tamanho do espaço aberto por diferentes tipos de variáveis

1. O tamanho do espaço aberto por tipos embutidos

`#include<stdio.h>
int main()
{
    
    
	printf("%d\n", sizeof(char));       //1
	printf("%d\n", sizeof(short));      //2
	printf("%d\n", sizeof(int));        //4
	printf("%d\n", sizeof(long));       //4
	printf("%d\n", sizeof(long long));  //8
	printf("%d\n", sizeof(float));      //4
	printf("%d\n", sizeof(double));     //8
}`

2. O tamanho do espaço aberto pelo tipo personalizado

tamanho da matriz

#include<stdio.h>
int main()
{
    
    
	int arr1[10] = {
    
     0 };       //40
	char arr2[10] = {
    
     0 };      //10
	long int arr3[10] = {
    
     0 };  //40
	long long arr4[10] = {
    
     0 }; //80
	float arr5[10] = {
    
     0 };     //40
	double arr6[10] = {
    
     0 };    //80
	printf("%d\n", sizeof(arr1));
	printf("%d\n", sizeof(arr2));
	printf("%d\n", sizeof(arr3));
	printf("%d\n", sizeof(arr4));
	printf("%d\n", sizeof(arr5));
	printf("%d\n", sizeof(arr6));
	return 0;
}

A partir dos resultados acima, podemos desenhar facilmente: o tamanho do array = o tipo dos elementos do array multiplicado pelo número de elementos

Outros tamanhos de tipo personalizado

#include<stdio.h>
struct Test1{
    
    
	int a;
	char b;
	float c;
	double d;
};
union Test2{
    
    
	int m;
	char n;
};
enum Test3 {
    
    
	monday,
	tuesday,
	wednesday,
	thursday,
	frifay
};
int main()
{
    
    
	struct Test1 test1 = {
    
     0 };
	union Test2 test2 = {
    
     0 };
	enum Test3 test3;
	printf("%d\n", sizeof(test1));   //24
	printf("%d\n", sizeof(test2));   //4
	printf("%d\n", sizeof(test3));   //4
}

Presumivelmente, os resultados acima são diferentes dos resultados na mente de alguns pequenos parceiros. Na verdade, o tamanho dos tipos personalizados, como estruturas, uniões e enumerações, e o tamanho do array não são os mesmos. Os métodos específicos envolvem alinhamento de memória Terminal, alocação de memória e outros conhecimentos relacionados, esses conhecimentos são mais complicados, vou explicar no módulo detalhado do tipo personalizado, e agora você não precisa entrar nele.

3. O tamanho do espaço aberto pelo tipo de ponteiro

Como você pode ver, não importa qual seja o tipo do ponteiro (inteiro, caractere, ponto flutuante, array), o tamanho do ponteiro é sempre quatro bytes ou oito bytes (a primeira imagem X86 representa plataforma de 32 bits, o resultado é 4, a segunda imagem X64 representa a plataforma de 64 bits, o resultado é 8), então a conclusão é: o ponteiro é de 4 bytes na plataforma de 32 bits e 8 bytes na plataforma de 64 bits. (Quanto a isso, isso envolve conhecimento de endereçamento de memória, linhas de endereço, etc. Vou explicar essa parte em detalhes no ponteiro. Agora você só precisa lembrar desta conclusão)
Nota: A segunda imagem tem um aviso porque meu computador é uma plataforma de 32 bits e forçá-lo para 64 bits causará uma incompatibilidade de tamanho.

4. O tamanho do espaço aberto pelo tipo vazio

Podemos ver que embora o compilador reporte um erro aqui, ele ainda imprime o tamanho de void: 0
bytes resultado pode ser diferente em diferentes ambientes de programação, por exemplo, no ambiente Linux, o tamanho do tipo void é 1, (devido à limitação de nível, não pode ser demonstrado aqui por enquanto); A razão fundamental para a diferença é que diferentes ambientes de compilação têm diferentes graus de suporte para a linguagem C.

4. Maior compreensão do tamanho de

1. Por que sizeof não é uma função

Do exposto, podemos ver que podemos usar sizeof(a) e sizeof(int) para encontrar o tamanho de um inteiro. Esse método também é familiar para todos, mas descobrimos que
sizeof a também pode ser usado para encontrar o tamanho de a diretamente, e Sem parênteses são necessários, então sizeof é uma palavra-chave (operador), mas não uma função, porque os parâmetros da função precisam ser () para serem usados ​​corretamente.
Observação: sizeof int relata um erro porque sizeof e int são ambas palavras-chave e você não pode usar uma palavra-chave para encontrar o tamanho de outra palavra-chave

2. Outros usos de sizeof

Aqui definimos uma variável inteira a e uma variável ponteiro p, bem como um array arr. Podemos ver que o tamanho de a é 4 e o tamanho de arr é 40. Todos nós entendemos isso,
então o tamanho restante de § , tamanho de (&arr), o que significa sizeof(arr) / sizeof(arr[0])? O seguinte é uma explicação para todos (envolvendo conhecimento relacionado ao ponteiro)

p é uma variável de ponteiro, que armazena o endereço de a, arr array name indica o endereço (memória) do primeiro elemento do array arr, &arr indica o endereço de todo o array, que é equivalente a um ponteiro de array, então sizeof § e sizeof(&arr) Ambos são o tamanho do ponteiro procurado e, como sabemos acima, o ponteiro tem 4 bytes na plataforma de 32 bits, então o resultado aqui é 4.
Finalmente, sizeof(arr) encontra o tamanho de todo o array e sizeof(arr[0]) encontra o tamanho do primeiro elemento, então dividir os dois resulta em 10 elementos do array.
Nota: sizeof(arr[0]) é usado aqui para encontrar o tamanho de um elemento do array, em vez de arr[1], arr[2] porque não sabemos quantos elementos o array tem, então talvez arr[1 ], arr [2] não existe, mas enquanto o array estiver definido, então arr[0] deve existir, ou seja, é feito por segurança.

Mais palavras-chave estão no link do blog abaixo
Explicação detalhada das palavras-chave da linguagem C (1) Auto, registrar palavra-chave
explicação detalhada das palavras-chave da linguagem C (2) Leva você a uma compreensão abrangente da estática

         码字不易，求个三连