Monster Br
Monster Br

Monster Br

Conectar-se

Esqueci minha senha



Os que mais criam tópicos
~Sah~
 
Hazec
 
~iHunt
 
Haou
 
Capslock
 
sasuky
 
@Dean..
 
DouglasTX
 
Compactor
 
Fadde
 

Top dos mais postadores
~Sah~ (245)
 
Hazec (46)
 
sasuky (23)
 
~iHunt (14)
 
Haou (11)
 
Capslock (8)
 
Skyke (6)
 
Evandroo (5)
 
Compactor (4)
 
@Dean.. (3)
 

Deseja outro tamanho de banner ? Contacte a Administração !
tudosobrejos clique aqui tudosobrejos clique aqui Tribus fórum clique aqui !
Convidado , Quer ser nosso parceiro ? Adicione nosso banner em seu fórum e peça Parceria . Não esquece de ler as regras de parceria !
Painel de Controle
Convidado
Mensagens: 0
Alterar
Informações
Preferências
Assinatura
Avatar
Ver
Amigos & ignorados
Tópicos supervisionados
Rascunhos
Tópicos favoritos
Ficha de personagem
Tópicos & Mensagens
Mensagens Privadas
Meus tópicos
Tópicos que participa
Minhas mensagens
Últimos tópicos

Você não está conectado. Conecte-se ou registre-se

Aprendendo Linguagem C++ [Parte3]

Ver o tópico anterior Ver o tópico seguinte Ir em baixo  Mensagem [Página 1 de 1]

1 Aprendendo Linguagem C++ [Parte3] em Sab Out 22, 2011 9:46 am

~Sah~

avatar
Admininistrador
Admininistrador
Em Base De Nossas Aulas , Hoje Trago a Parte 3 Do Tutorial Que se baseia em Constantes , Literais , algarismos Inteiros , Numeros de Ponto Flutuante , Literais de Caracteres e cadeia , Boolean Literais , Constantes Definidas e Constantes declaradas.
Faça bom Aproveito ;D!

Constantes
Constantes são expressões com um valor fixo.

Literais
Literais são o tipo mais óbvio de constantes. Eles são usados ​​para expressar valores particulares dentro do código fonte de um programa. Nós já usamos esses anteriormente para dar valores concretos para as variáveis ​​ou para expressar as mensagens que queríamos nossos programas para imprimir, por exemplo, quando escreveu:


a = 5;


a 5 , neste pedaço de código era um constante literal . constantes Literal pode ser dividido em numerais Integer , de ponto flutuante numerais , caracteres , strings e valores booleanos .



Algarismos inteiro


1776
707
-273


Eles são constantes numéricas que identificam valores decimais inteiro. Repare que para expressar uma constante numérica não temos que escrever aspas ( " ) nem qualquer caractere especial Não há dúvida de que é uma constante:. sempre que escrever 1776 . em um programa, vamos estar se referindo ao valor de 1776 em Além de números decimais (aqueles que todos nós estamos acostumados a usar todos os dias), C + + permite o uso de números octais ( base 8 ) e hexadecimais ( base 16 ) como constantes literais. Se queremos expressar um número octal temos que precedê-la com um 0 (a de zero . personagem) E, a fim de expressar um número hexadecimal, precisamos precedê-lo com os caracteres 0x ( de zero , x ). Por exemplo, as seguintes constantes literais são todas equivalentes entre si:



75 / decimal /
0113 / / octal
0x4B / hexadecimal /


Todos estes representam o mesmo número:. 75 (75), expressa em numeral de base 10, numeral octal e hexadecimal numeral, respectivamente constantes Literal, como variáveis, são considerados como tendo um tipo de dados específico. Por padrão, literais inteiros são do tipo int . No entanto, podemos forçá-los a ser ou não assinado, anexando o u personagem para ela, ou a longo prazo, acrescentando l :



75 / / int
75U / / unsigned int
75L / / longo
75ul / / unsigned long


Em ambos os casos, o sufixo pode ser especificado usando letras maiúsculas ou minúsculas.

Números de ponto flutuante
Eles expressam números com casas decimais e / ou expoentes. Eles podem incluir um ponto decimal, um e personagem (que expressa "por dez, no auge Xth", onde X é um valor inteiro que segue o e personagem), ou ambos um ponto decimal e um e personagem:


3,14159 / / 3,14159
6.02e23 / / 6,02 x 10 ^ 23
1.6e-19 / / 1,6 x 10 ^ -19
3,0 / / 3,0


Estes são quatro números decimais válido com expressa em C + +. O primeiro número é PI, o segundo é o número de Avogadro, a terceira é a carga elétrica de um elétron (um número extremamente pequeno), todos eles aproximado e o último é o número três expresso como um ponto flutuante literal numérico. O tipo padrão para literais de ponto flutuante é dupla . Se você quer expressar explicitamente uma bóia ou um long double literal numérico, você pode usar o f ou l sufixos, respectivamente:


3.14159L / / long double
6.02e23f / / float


Qualquer uma das letras que podem ser parte de um ponto flutuante constante numérica ( e , f , l ) pode ser escrito usando letras minúsculas ou maiúsculas sem qualquer diferença de seus significados.

Literais de caracteres e cadeia
Também existem não-numéricos constantes, como:


'Z'
'p'
"Olá mundo"
"Como você faz?"


As duas primeiras expressões representam constantes único caractere, e os dois seguintes representam literais string composta de vários personagens. Observe que para representar um único caractere que colocá-lo entre aspas simples ( ' ) e para expressar uma string (que geralmente consiste de mais de um personagem) que incluí-la entre aspas ( " ). Ao escrever o caráter único e literais string, é necessário colocar as aspas em torno deles para distingui-los de possíveis identificadores de variáveis ​​ou palavras-chave reservadas Observe a diferença entre essas duas expressões.:



'x'


x só remete para uma variável cujo identificador é x , enquanto que 'x' (entre aspas simples) remete para o caráter constante 'x' . literais de caracteres e strings possuem certas peculiaridades, como os códigos de escape. Estes são caracteres especiais que são difíceis ou impossíveis de expressar de outra forma no código fonte de um programa, como nova linha ( \ n ) ou tabulação ( \ t ). Todos eles são precedidos por uma barra invertida ( \ ). Aqui você tem uma lista de alguns dos códigos de escape como:



\ N newline
\ R retorno de carro
\ T tabulação
\ V tabulação vertical
\ B retrocesso
\ F alimentação de formulário (feed página)
\ A alert (bip)
\ ' aspas simples (')
\ " aspas duplas (")
\? ponto de interrogação (?)
\ \ barra invertida (\)

Por exemplo:


'\ N'
'\ t'
"direito \ esquerdo t"
"um \ nDuas \ nthree"


Além disso, você pode expressar qualquer personagem com o seu código numérico ASCII escrevendo um caractere de barra invertida ( \ ) seguido do código ASCII expresso como um octal ( base 8 ) ou (hexadecimal base-16 de número). No primeiro caso (octal) os dígitos deve seguir imediatamente a barra invertida (por exemplo \ 23 ou \ 40 ), no segundo caso (hexadecimal), um x personagem deve ser escrito antes dos dígitos si (por exemplo \ x20 ou \ x4A ). string literais pode se estender para mais do que uma única linha de código, colocando um sinal de barra invertida ( \ ) no final de cada linha inacabado.



"String expressa em \
duas linhas "


Você também pode concatenar várias constantes de cadeia separando-os por um ou vários espaços em branco, tabuladores, nova linha ou qualquer caractere válido outro em branco:


"Esta forma" um "single" "string" "de caracteres"


Finalmente, se queremos que a seqüência de caracteres literal que deverão ser explicitados de caracteres de largura ( wchar_t tipo), em vez de caracteres estreitos ( de char tipo), que pode preceder a constante com o L prefixo:


L "Esta é uma cadeia de caracteres wide"


Caracteres de largura são usados ​​principalmente para representar conjuntos de caracteres não-Inglês ou exóticos.

Boolean literais
Existem apenas duas válido valores booleanos: verdadeiro e falso . Estes podem ser expressos em C + + como valores do tipo bool usando o Boolean literais verdadeiro e falso .

Constantes definidas (# define)
Você pode definir seus próprios nomes para constantes que você usa muito frequentemente sem ter que recorrer à memória-consuming variáveis, simplesmente usando o # define directiva pré-processador. Seu formato é: # define identificador valor Por exemplo:




# Define PI 3,14159
# define nova linha '\ n'


Isto define duas constantes novo: PI e NEWLINE . Uma vez que eles são definidos, você pode usá-los no resto do código como se fosse qualquer outra constante regular, por exemplo:


/ / Constantes definidas: calcular a circunferência

# Include
usando namespace std;

# Define PI 3,14159
# define nova linha '\ n'

int main ()
{
dupla r = 5,0; / raio /
duplo círculo;

círculo = 2 * PI * r;
cout <cout <
retornar 0;
}
31,4159


Na verdade a única coisa que o pré-processador do compilador faz quando encontra # define diretrizes é, literalmente, substituir qualquer ocorrência do seu identificador (no exemplo anterior, estes eram PI e NEWLINE ) pelo código a que tenham sido definidos ( 3,14159 e ' \ n ' . respectivamente) O # define directiva não é um C + +, mas uma declaração de diretiva para o pré-processador, por isso ele assume toda a linha como a directiva e não requer um ponto e vírgula ( ; ) em sua extremidade. Se você acrescentar um caractere ponto e vírgula ( ; ) no final, ele também será anexado em todas as ocorrências do identificador dentro do corpo do programa que o pré-processador substitui.



Constantes declaradas (const)
Com a const prefixo que você pode declarar constantes com um tipo específico da mesma forma como você faria com uma variável:


const int pathwidth = 100;
const caractere de tabulação = '\ t' ;


Aqui, pathwidth e tabulação são duas constantes digitado. Eles são tratados como variáveis ​​regulares, exceto que seus valores não podem ser modificados após a sua definição.



Spoiler:






Spoiler:
Sou Fãn:

http://monsterbr.forumfacil.net

Ver o tópico anterior Ver o tópico seguinte Voltar ao Topo  Mensagem [Página 1 de 1]

Permissão deste fórum:
Você não pode responder aos tópicos neste fórum