Phenquestions
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 C ++. Você já deve ter conhecimento básico de C ++ para entender este artigo.
Conteúdo do Artigo
- Tipos Fundamentais
- Maneiras de construir tipos compostos
- Matrizes
- Enumeração
- Aula
- União
- Referências
- Funções
- Outros Tipos Compostos
- Conclusão
Tipos Fundamentais
Tipos fundamentais são tipos escalares.
bool
Um tipo booleano ou tipo booleano tem um valor verdadeiro ou falso para 1 ou 0. Verdadeiro ou falso ocupa um byte.
char, unsigned char e assinado char
Um char é normalmente para um personagem 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. Os caracteres sem sinal não envolvem valores negativos, enquanto os caracteres assinados envolvem valores negativos. O tipo de valor que um char possui depende do compilador e pode ser apenas um char não assinado. Esses três tipos de caracteres são chamados de tipos de caracteres restritos e cada um ocupa um byte.
Inteiro
Existem cinco tipos de inteiros padrão sem sinal e cinco tipos de inteiros padrão com sinais. Os cinco tipos inteiros sem sinal são: “unsigned char”, “unsigned short int”, “unsigned int”, “unsigned long int” e “unsigned long int”. Os cinco tipos de inteiros com sinal correspondentes são: "sinal assinado", "curto int", "int", "int longo" e "int longo longo".
“Unsigned char” é o mesmo tipo que os tipos de caracteres estreitos (veja acima). “Sinal assinado” é o outro tipo de tipo de caractere restrito (veja acima).
Com o compilador g ++, “unsigned char” ou “signed char” ocupa um byte; “Unsigned short int” ou “short int” ocupa dois bytes; “Unsigned int” ou “int” ocupa quatro bytes; “Unsigned long int” ou “long int” ocupa 8 bytes; “Unsigned long long int” ou “long long int” ainda ocupa 8 bytes (a partir de agora).
char16_t, char32_t, wchar_t
Ao lidar com caracteres da Europa Ocidental, o tipo char é suficiente em muitas situações. No entanto, ao lidar com chinês e outros idiomas orientais, char16_t ou char32_t ou wchar_t é necessário. 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, o assinado e os tipos inteiros não assinados formam outro conjunto, chamados de tipos integrais (inteiros).
Neste ponto do artigo, dois tipos coletivos foram mencionados: tipos de caracteres restritos e tipos integrais.
Tipos de ponto flutuante
Suponha que os números 457.000 e 457.230 sejam a mesma leitura, medida por dois instrumentos de medição diferentes. 457.230 é mais preciso do 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 outros.
Alguns instrumentos de medição realizam medições em etapas mínimas, digamos 10 unidades. Tal 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 alguns passos mínimos (muito menores do que 10 unidades).
C ++ tem três tipos de ponto flutuante, que são: float, double e long double. Para qualquer compilador, double deve ter a precisão maior do que float ou pelo menos float; o duplo longo deve ter a precisão maior que a do duplo ou pelo menos a do duplo.
Há um terceiro nome coletivo: tipo aritmético. Este é o nome dos tipos integrais e de ponto flutuante. Observe que este também é o nome de todos os tipos escalares, conforme explicado até agora.
Com o compilador g ++, o número de bytes para um float é quatro; o número de bytes para um duplo é oito; o número de bytes para um duplo longo é dezesseis.
tipo vazio
Com o compilador g ++, o tamanho do tipo void é de um byte. O byte oficialmente não tem bits, o que significa que sua localização tem conteúdo vazio.
Maneiras de construir tipos compostos
Tipos compostos são tipos não fundamentais. Isso significa que os tipos compostos são tipos não escalares. Esta seção explica os fundamentos dos tipos compostos.
Arrays
O seguinte segmento de código mostra uma matriz de ints e uma matriz de chars:
arrInt int [] = 1, 2, 3, 4, 5;char arrCha [] = 'a', 'b', 'c', 'd', 'e';
cout << arrInt[2] <<" <
Enumeração
Uma enumeração é um tipo, com constantes nomeadas. Considere o seguinte segmento de código:
enum a = 3, b, c;cout << b <<'\n';
O resultado é: 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 a partir da qual muitos objetos da mesma unidade generalizada podem ser criados (instanciados). O programa a seguir mostra uma classe e dois objetos, instanciados a partir dela. Esse objeto é diferente de um objeto escalar.
#incluirusando namespace std;
classe TheCla
público:
int num = 5;
int fn ()
return num;
;
int main ()
TheCla obj1;
TheCla obj2;
cout << obj1.num << " << obj2.num <<'\n';
return 0;
O resultado é: 5 5. O nome da classe é TheCla, e os nomes dos dois objetos são obj1 e obj2. Observe o ponto-e-vírgula logo após a descrição (definição) da classe. Observe como os dois objetos foram instanciados na função main ().
Nota: num é um membro de dados e fn é uma função membro.
União
estrutura
Uma estrutura é como uma matriz, mas em vez de ter pares de índice / valor, ela 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;
struct TheCla
int num = 5;
float flt = 2.3;
char ch = 'a';
obj1, obj2;
int main ()
cout << obj2.num <<", "<< obj2.flt <<", "<< obj2.ch <<'\n';
return 0;
O resultado é:
5, 2.3, a
O 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;
união TheCla
int num;
float flt = 2.3;
char ch;
obj1, obj2;
int main ()
cout << obj2.flt <<'\n';
return 0;
O resultado é: 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ó pode ter um valor próximo se o valor para flt for abandonado.
Referências
Uma referência é um sinônimo de um identificador. O segmento de código a seguir mostra como obter uma referência a um identificador:
id int = 5;int & ref1 = id;
int & ref2 = id;
cout << id << " << ref1 << " << ref2 <<'\n';
O resultado é: 5 5 5. ref1 e ref2 são sinônimos de id.
Referência lvalue e Referência rvalue
As referências acima são referências de valor. O código a seguir mostra a referência de rvalue:
int && ref = 5;cout << ref <<'\n';
O resultado é: 5. Esta referência é criada sem identificar qualquer local na memória. Para conseguir isso, é necessário dobrar &, i.e., &&.
Pointer
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';
O resultado é: 5. Observe a diferença de nome entre ptdId e ptdId. ptdId é o objeto apontado e ptrId é o objeto de ponteiro. & ptdId retorna o endereço do objeto apontado que é atribuído a ptrId. Para retornar o valor do objeto apontado, use * ptrId.
Funções
Função básica e sua chamada
O código a seguir mostra uma definição de função básica e sua chamada:
#incluirusando namespace std;
int fn (int num)
cout<<"seen"<<'\n';
return num;
int main ()
ret int = fn (5);
cout << ret <<'\n';
return 0;
A saída é
definição de função
5
A chamada de função é fn (5). O nome da função é fn.
Referência e ponteiro para uma função
& fn retorna o endereço na memória da função cujo nome é fn. A instruçã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. função pode ser configurada para conter o endereço de uma função identificada por fn, como segue:
func = &fn;O programa a seguir coloca a referência de função e o ponteiro em ação:
#incluirusando namespace std;
int fn (int num)
/ * algumas declarações * /
return num;
int main ()
int (* função) (int);
func = &fn;
ret int = função (5);
cout << ret <<'\n';
return 0;
O resultado é: 5. Observe que tanto fn quanto func têm o parâmetro int na declaração.
Outros Tipos Compostos
Os tipos de compostos básicos acima são compostos por si próprios. Eles também são usados para construir tipos de compostos elaborados.
typedef
A palavra reservada typedef é usada para substituir uma sequência de tipos por um nome (para a sequência). O seguinte segmento de código ilustra isso:
typedef unsigned long int IduIL;
IduIL myInt = 555555555555555555;cout << myInt <<'\n';
A saída é 555555555555555555. No código, IduIL se tornou um tipo que significa “unsigned long int”.
Encadernação Estruturada
A vinculação estruturada é um recurso que possibilita que nomes sejam dados a subobjetos. O código a seguir ilustra isso para a matriz:
int arr [3] = 1, 2, 3;auto [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, auto. Além disso, observe o uso de colchetes.
Bit-Field
A memória é uma sequência de células. Cada célula leva 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 um ao lado 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 de estruturadia sem sinal curto wkDay: 3; // 3 bits
curto sem sinal segunda-feira: 6; // 6 bits
sem sinal curto seg: 5; // 5 bits
ano curto sem sinal: 8; // 8 bits para ano de 2 dígitos
dte;
dte.wkDay = 1; dte.monDay = 2; dte.mon = 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, MonDay e mon é 3 + 6 + 5 = 14. Portanto, dois bits de preenchimento seriam adicionados para formar 16 bits para o número inteiro curto de 2 bytes (16 bits). Os próximos 8 bits começam o próximo int curto, que é então preenchido com 8 bits de preenchimento.
Nota: Evite usar campos de bits; use-o apenas para pesquisa.
Namespace
Um namespace é 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 namespaces diferentes, aplicados no namespace da função main ():
#incluirusando namespace std;
namespace NS1
int myInt = 8;
float flt;
namespace NS2
int myInt = 9;
float flt;
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';
return 0;
O resultado é:
9
8
2.5
4.8
Existem dois nomes internos conflitantes e dois nomes flutuantes conflitantes no código.
Especialização em modelo e modelo
O esquema do 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;
template void func (T cha, U no)
cout << "I need bread for " << cha << no << '.' << '\n';
int main ()
função ('$', 3);
return 0;
O resultado é:
“Eu preciso de pão por $ 3.”
Pacote de parâmetros de modelo
Os compiladores ainda não implementaram totalmente esse recurso - veja mais tarde.
Conclusão
Os tipos C ++ existem em duas categorias: tipos fundamentais e tipos compostos. Tipos fundamentais são tipos escalares. Tipos compostos básicos são matrizes, enumerações, classes, uniões, referências, ponteiros e funções. Esses tipos compostos básicos são usados para construir tipos compostos elaborados, que são typedef, ligações estruturadas, campos de bits, namespace e recursos de modelo.
Chrys
