Tipos C ++
A memória de um computador é uma série de células. Cada célula tem o tamanho de um byte, normalmente é o espaço ocupado por um personagem da Europa Ocidental. O tamanho de um objeto é dado em bytes. Este artigo fornece um resumo dos tipos de C ++. Você já deve ter conhecimento básico de C ++, a fim de entender este artigo.
Conteúdo do artigo
- Tipos fundamentais
- Maneiras de construir tipos de compostos
- Matrizes
- Enumeração
- Aula
- União
- Referências
- Funções
- Outros tipos de compostos
- Conclusão
Tipos fundamentais
Tipos fundamentais são tipos escalares.
bool
Um tipo booleano ou tipo bool tem um valor de verdadeiro ou falso para 1 ou 0. Verdadeiro ou falso ocupa um byte.
char, char não assinado e char assinado
Um carvão é tipicamente para um caráter da Europa Ocidental. Normalmente ocupa um byte. Há também um char não assinado e assinado, que é um número inteiro de oito bits. Carreços não assinados não envolvem valores negativos, enquanto os chars assinados envolvem valores negativos. O tipo de valor que um char mantém depende do compilador e pode ser apenas um char não assinado. Esses três tipos de chars são chamados de tipos de caracteres estreitos, e cada um ocupa um byte.
Inteiro
Existem cinco tipos inteiros padrão não assinados e cinco tipos inteiros padrão assinados. Os cinco tipos inteiros não assinados são: “char não assinado”, “Int curto não assinado,“ Int não assinado ”,“ Int Long Int não assinado e “Int Long Int Long Long”. Os cinco tipos inteiros assinados correspondentes são: "Char assinado", "Short Int", "Int", "Long Int" e "Long Long Int".
"Char não assinado" é o mesmo tipo que os tipos estreitos de caracteres (veja acima). "Char assinado" é o outro tipo de tipo de caractere estreito (veja acima).
Com o compilador G ++, "char não assinado" ou "char assinado" ocupa um byte; “Int curto não assinado ou“ curto int ”ocupa dois bytes; "Int não assinado" ou "int" ocupa quatro bytes; “Long Int não assinado ou“ Long Int ”ocupa 8 bytes; “Não assinado Long Int” ou “Long Long Int” ainda ocupa 8 bytes (a partir de agora).
char16_t, char32_t, wchar_t
Ao lidar com os personagens da Europa Ocidental, o tipo de char é suficiente em muitas situações. No entanto, ao lidar com os idiomas chineses e outros do leste, é necessário char16_t ou char32_t, ou wchar_t. Com o compilador G ++, Char16_T ocupa dois bytes; char32_t ocupa quatro bytes e wchar_t também ocupa quatro bytes.
O bool, o char, o char16_t, o char32_t, o wchar_t, os tipos inteiros assinados e os não assinados, formam outro conjunto, chamado de tipos integrais (inteiros).
Neste ponto do artigo, dois tipos coletivos foram mencionados: tipos estreitos de caracteres e tipos integrais.
Tipos de ponto flutuante
Suponha que os números 457.000 e 457.230 sejam a mesma leitura, medidos por dois instrumentos de medição diferentes. 457.230 é mais preciso que 457.000 porque o valor é mais detalhado (envolve lugares menores: + 200 mais 30). Um número de ponto flutuante é um número com uma parte fracionária (decimal). Embora os números no computador sejam uma sequência de bits, alguns números de ponto flutuante são mais precisos do que os outros.
Alguns instrumentos de medição tomam medições em etapas mínimas, digamos 10 unidades. Esse instrumento teria as seguintes leituras: 10, 20, 30, 40,… 100, 110, 130, 140,… 200, 210, 220, 230, 240 e assim por diante. Embora os números no computador sejam uma sequência de bits, os números de ponto flutuante variam em algumas etapas mínimas (muito menor que 10 unidades).
C ++ tem três tipos de ponto flutuante, que são: flutuação, dupla e longa dupla. Para qualquer compilador, o dobro deve ter a precisão maior que a de flutuação ou pelo menos a de flutuação; o duplo longo deve ter a precisão maior que a de dupla ou pelo menos a de dupla.
Há um terceiro nome coletivo: tipo aritmético. Este é o nome para tipos integrais e de ponto flutuante. Observe que este também é o nome para todos os tipos escalares, conforme explicado até agora.
Com o compilador G ++, o número de bytes para um flutuador é quatro; O número de bytes por um dobro é oito; O número de bytes por um longo duplo é dezesseis.
tipo vazio
Com o compilador G ++, o tamanho do tipo vazio é um byte. O byte oficialmente não tem pedaços, o que significa que sua localização tem conteúdo vazio.
Maneiras de construir tipos de compostos
Tipos de compostos são tipos não fundamentais. Isso significa que os tipos de compostos são tipos não escalares. Esta seção explica o básico dos tipos de compostos.
Matrizes
O segmento de código a seguir mostra uma matriz de INTs e uma variedade de chars:
int arrist [] = 1, 2, 3, 4, 5;char Arrcha [] = 'A', 'B', 'C', 'D', 'E';
cout << arrInt[2] <<" <
Enumeração
Uma enumeração é um tipo, com constantes nomeados. Considere o seguinte segmento de código:
enum a = 3, b, c;cout << b <<'\n';
A saída é: 4. A primeira linha do segmento de código é uma enumeração, e a, b ou c é um enumerador.
Aula
Uma classe é uma unidade generalizada da qual muitos objetos da mesma unidade generalizada podem ser criados (instanciados). O programa a seguir mostra uma classe e dois objetos, instanciados dele. Esse objeto é diferente de um objeto escalar.
#incluirusando namespace std;
CLASSE THECLA
público:
int num = 5;
int fn ()
retornar num;
;
int main ()
Thecla obj1;
Thecla obj2;
cout << obj1.num << " << obj2.num <<'\n';
retornar 0;
A saída é: 5 5. O nome da classe é o TheCla, e os nomes dos dois objetos são obj1 e obj2. Observe o semicolon logo após a descrição (definição) da classe. Observe como os dois objetos foram instanciados na função principal ().
Nota: Num é um membro de dados e FN é uma função de membro.
União
estrutura
Uma estrutura é como uma matriz, mas em vez de ter pares de índice/valor, ele tem pares de nome/valor. Os nomes podem ser escritos em qualquer ordem. O programa a seguir mostra uma estrutura e seu uso:
#incluirusando namespace std;
estrutura thecla
int num = 5;
flutuar FLT = 2.3;
char ch = 'a';
obj1, obj2;
int main ()
cout << obj2.num <<", "<< obj2.flt <<
","<< obj2.ch <<'\n';
retornar 0;
A saída é:
5, 2.3, aO nome da estrutura é thecla. obj1 e obj2 são dois objetos diferentes da estrutura.
União
O programa a seguir mostra um sindicato e seu uso:
#incluirusando namespace std;
Union thecla
int num;
flutuar FLT = 2.3;
char ch;
obj1, obj2;
int main ()
cout << obj2.flt <<'\n';
retornar 0;
A saída é: 2.3. A união é semelhante a uma estrutura. A principal diferença entre uma estrutura e uma união é que, para uma estrutura, apenas um membro pode ter um valor (inicializado) a qualquer momento. No programa acima, o membro, FLT tem um valor de 2.3. Cada um dos outros membros, num ou ch, só poderá ter um valor a seguir se o valor para FLT for abandonado.
Referências
Uma referência é um sinônimo de identificador. O segmento de código a seguir mostra como obter uma referência a um identificador:
int id = 5;int & ref1 = id;
int & ref2 = id;
cout << id << " << ref1 <<
" << ref2 <<'\n';
A saída é: 5 5 5. Ref1 e Ref2 são sinônimos para identificar.
referência de lvalue e referência de rvalue
As referências acima são referências de LValue. O código a seguir mostra a referência de RValue:
int && ref = 5;cout << ref <<'\n';
A saída é: 5. Esta referência é criada sem identificar nenhum local na memória. Para conseguir isso, o dobro e é necessário, eu.e., &&.
Ponteiro
Um ponteiro não é realmente uma entidade C ++. No entanto, fornece um esquema melhor para lidar com referências. O código a seguir mostra como um ponteiro pode ser criado:
int ptdid = 5;int ptdid = 5;
int *ptrid;
ptrid = &ptdId;
cout << *ptrId <<'\n';
A saída é: 5. Observe a diferença no nome entre ptdid e ptdid. ptdid é o objeto pontiagudo e ptrid é o objeto de ponteiro. & ptdid retorna o endereço do objeto pontiagudo que é atribuído ao ptrid. Para retornar o valor do objeto pontiagudo, use *ptrid.
Funções
Função básica e sua chamada
O código a seguir mostra uma definição básica de função e sua chamada:
#incluirusando namespace std;
int fn (int num)
cout<<"seen"<<'\n';
retornar num;
int main ()
int ret = fn (5);
cout << ret <<'\n';
retornar 0;
A saída é
visto5
A chamada de função é fn (5). O nome da função é fn.
Referência e ponteiro para uma função
& fn retornam o endereço na memória da função cujo nome é fn. A declaração a seguir declara um ponteiro para uma função:
int (*func) ();Aqui, func é o nome do ponteiro para a função. O primeiro par de parênteses diferencia este ponteiro de função de um ponteiro de objeto escalar. Func pode ser feito para manter o endereço de uma função identificada pelo FN, como segue:
func = &fn;O programa a seguir coloca a referência da função e o ponteiro em ação:
#incluirusando namespace std;
int fn (int num)
/ * Algumas declarações */
retornar num;
int main ()
int (*func) (int);
func = &fn;
int ret = func (5);
cout << ret <<'\n';
retornar 0;
A saída é: 5. Observe que o FN e o FUNC têm o parâmetro int na declaração.
Outros tipos de compostos
Os tipos de compostos básicos acima são compostos em si mesmos. Eles também são usados para construir tipos de compostos elaborados.
typedef
A palavra typedef reservada é usada para substituir uma sequência de tipos por um nome (para a sequência). O seguinte segmento de código ilustra o seguinte:
typedef não assinado Long int iDuil;Iduil myint = 5555555555555555555;
cout << myInt <<'\n';
A saída é 5555555555555555555. No código, o iduil se tornou um tipo que significa “Int Int não assinado.
Ligação estruturada
A ligação estruturada é um recurso que possibilita que os nomes sejam dados aos subobjetos. O código a seguir ilustra isso para a matriz:
int arr [3] = 1, 2, 3;automático [x, y, z] (arr);
cout << x <<"<< y <<"<< z <<'\n';
A saída é 1 2 3. Então, os valores: 1, 2, 3 receberam os nomes, x, y, z. Observe o uso e a posição da palavra reservada, automático. Além disso, observe o uso dos colchetes.
Campo de bits
A memória é uma sequência de células. Cada célula pega um byte. Além disso, cada byte consiste em oito bits. Um grupo de bits, não necessariamente oito bits, pode ser definido e alterado. Esse grupo é chamado de campo de bits. Esses grupos ficariam próximos um do outro. Se os grupos não formarem um tipo, digamos 16 bits para um Int curto, bits de preenchimento são adicionados. O código a seguir ilustra isso com a estrutura:
Data da estruturacurto -dia não assinado: 3; // 3 bits
Segunda -feira curta não assinada: 6; // 6 bits
não assinado seg. // 5 bits
YR curto não assinado: 8; // 8 bits por 2 dígitos ano
dte;
dte.wkday = 1; dte.Segunda -feira = 2; dte.Seg = 2; dte.ano = 21;
cout << dte.mon <<'/'<< dte.monDay <<'/'<< dte.yr <<'\n';
A saída é: 2/2/21. O número total de bits para Wkday, segunda -feira, e Mon é 3 + 6 + 5 = 14. Então, dois bits de preenchimento seriam adicionados para compensar 16 bits para o número inteiro curto de 2 bytes (16 bits). Os próximos 8 bits começam o próximo curto Int, que é então preenchido com 8 bits de preenchimento.
Nota: Evite usar campos de bits; Use -o apenas para pesquisa.
Espaço para nome
Um espaço para nome é um conjunto de nomes, que não deve entrar em conflito com os mesmos nomes de outros conjuntos de nomes. O programa a seguir ilustra o uso dos mesmos nomes de dois espaços de nome diferentes, aplicados no espaço de nome da função Main ():
#incluirusando namespace std;
namespace ns1
int myint = 8;
flutuar;
namespace ns2
int myint = 9;
flutuar;
int main ()
cout << NS1::myInt << '\n';
cout << NS2::myInt << '\n';
Ns1 :: flt = 2.5;
NS2 :: FLT = 4.8;
cout << NS1::flt << '\n';
cout << NS2::flt << '\n';
retornar 0;
A saída é:
98
2.5
4.8
Existem dois nomes int conflitantes e dois nomes de flutuação conflitantes no código.
Modelo e especialização de modelos
O esquema de modelo permite o uso de um espaço reservado para diferentes tipos escalares possíveis. A especialização é escolher um tipo escalar específico. O código a seguir ilustra isso para uma função:
#incluirusando namespace std;
modelo
Void func (t cha, u não)
cout << "I need bread for " << cha << no << '.' << '\n';
int main ()
func ('$', 3);
retornar 0;
A saída é:
Eu preciso de pão por $ 3.Pacote de parâmetros de modelo
Os compiladores ainda estão para implementar totalmente esse recurso - veja mais adiante.
Conclusão
Os tipos de C ++ existem em duas categorias: tipos fundamentais e tipos de compostos. Tipos fundamentais são tipos escalares. Tipos de compostos básicos são matrizes, enumerações, aulas, sindicatos, referências, ponteiros e funções. Esses tipos de compostos básicos são usados para construir tipos de compostos elaborados, que são tipedef, ligações estruturadas, campos de bits, espaço para nome e recursos de modelo.