Baixe apostila c++ e outras Notas de estudo em PDF para Engenharia Mecânica, somente na Docsity!
SUMÁRIO
Unidade I 1.0 Itens fundamentais......................................................................pg- 8 1.1 Dados Numéricos.........................................................................pg- 8 1.2 Dado literal...................................................................................pg- 8 2.0 Variável.........................................................................................pg- 8 2.1 Formação de Identificadores........................................................pg- 9 2.2 Declaração de variáveis.................................................................pg- 9 2.3 Modificadores de tipos oferecidos por c++...................................pg- 9
Operadores.....................................................................................pg- 10 3.1 Operadores de atribuição...............................................................pg- 10 3.2 Operadores aritméticos...................................................................pg- 10 4.0 Funções de entrada e saída..............................................................pg- 11
Entrada.............................................................................................pg- 11
Saída..................................................................................................pg- 11 5.0 Manipuladores de tamanho de campos na impressão.....................pg- 12 6.0 Funções aritméticas..........................................................................pg- 14 7.0 Operadores relacionais.....................................................................pg- 14 8.0 manipuladores de bases numéricas..................................................pg- 17 9.0 Imprimindo caracteres gráficos.......................................................pg- 17
- 0 Códigos Especiais............................................................................pg- 18 11.0Comentários..................................................................................... pg- 18 12 Estruturas condicionais.....................................................................pg- 19 13.0 Estruturas de repetições.................................................................pg- 22 13.1 Estrutura For..................................................................................pg- 22 13.2 Estrutura While..............................................................................pg- 23
1.1Chamando um função........................................................................pg- 35 1.2 Funções simples................................................................................pg- 35 1.3 Protótipo de funções..........................................................................pg- 35 1.4 Tipos de funções................................................................................pg- 36 1.5 O comando Return............................................................................pg- 36 1.6 Definição da função...........................................................................pg- 36 1.7 Parâmetros da função.......................................................................pg- 36 1.8 Passagem por valor...........................................................................pg- 37 1.9 Passagem vários argumentos............................................................pg- 38 1.10 O operador unário de referência:&...............................................pg- 39 1.11 Passagem por referência.................................................................pg- 40 1.12 Referência constantes.....................................................................pg- 41 1.13 Classes de argumentos....................................................................pg- 41
1.14 O operador de escopo.....................................................................pg- 42 1.15 Funções recursivas.........................................................................pg- 43 Unidade IV
Estruturas.......................................................................................pg- 45 1.1 Definindo a estrutura......................................................................pg- 45 1.2 Acessando os membros da estrutura...............................................pg- 46 1.3 Combinando declarações..................................................................pg- 46 1.4 Inicializando estruturas....................................................................pg- 46 1.5 Operações entre estruturas..............................................................pg- 46 1.6 Estruturas aninhadas........................................................................pg- 47 1.7 Passando estruturas para funções....................................................pg- 47 1.8 Matrizes de estruturas......................................................................pg- 48
Ponteiros............................................................................................pg- 69 1.1 Por que os ponteiros são usados.......................................................pg- 69 1.2 Ponteiros variáveis............................................................................pg- 70 1.3 Endereços de memória......................................................................pg- 70 1.4 Operador de endereços.....................................................................pg- 70 1.5 Passando argumentos por referência com ponteiros.......................pg- 71 1.6 variáveis que armazena endereços...................................................pg- 72 1.7 O operador indireto..........................................................................pg- 72 1.8 Passando endereços para a função...................................................pg- 72 1.9 Ponteiros sem funções.......................................................................pg- 72 1.1 0 Ponteiros e variáveis apontadas.....................................................pg- 73
atribuição.........................................................................................pg- 73 1.12 Operação indireta...........................................................................pg- 73
1.13 Trazendo o endereço do ponteiro...................................................pg- 74 1.14 Incremento em ponteiro..................................................................pg- 74 1.15 Ponteiro no lugar de matrizes.........................................................pg- 74 1.16 Ponteiros constantes e ponteiros variáveis.....................................pg- 74 1.17 Passando matrizes como argumento para funções........................pg- 75
Precedência.....................................................................................pg- 76 1.19 Ponteiros e strings...........................................................................pg- 76 1.20 Matrizes de ponteiros......................................................................pg- 77 1.21 Área de alocação dinâmica: Heap.................................................pg- 77 1.22 Retornado o ponteiro This..............................................................pg- 79 1.23 dimensionando matrizes em tempo de execução...........................pg- 79
É formado por qualquer seqüência de caracteres e vem entre aspas duplas. Ex. a) " 2040" b) " " c) " Não Fume" 2.0 - Variável É o endereço de memória (RAM) reservado para armazenar certo tipo de dado. Obs.: RAM - Memória dinâmica de acesso aleatório a leitura e escrita e é volátil.
Ex.: d 1 0 n ota 1 00 s exo f 2.1 - Formação de identificadores é formada por apenas uma letra ou então uma letra seguido de letras e dígitos nunca símbolos especiais. Obs.: A letra maiúscula é diferente de letra minúscula. Ex.: 1) funcao 3) media
- d 4) m Cuidado - MEDIA media 2.2 - Declaração de variáveis Tipo da variável < nome-do-identificador >; O ponto-e-vírgula manda o computador executar a próxima instrução. Nome-do-identificador são os nomes das variáveis separadas por vírgula. Tipo da variável pode ser do tipo int, float, double, char, etc. Ex.: int x,y;
Obs.: int tem sempre o tamanho da palavra da máquina, isto é, em computadores de 16 bits ele terá 16 bits de tamanho. Short tem tamanho diferente do tipo int, geralmente à metade do tamanho de um int. STRINGS são declaradas da seguinte maneira char nome[n]; Onde: n é o numero de caracteres da string. Ex.: int id,nm; float alt,peso; char nome[25]; char sexo; 3.0 - Operadores 3.1 - Operador de atribuição: = Representa a atribuição da expressão a sua direita a variável a sua esquerda. Ex.: 1) x = 200;
- y = 5; 3.2 - Operadores aritméticos
+ soma - subtração * multiplicação / divisão % resto da divisão de 2 números inteiros Prioridade Prioridade operadores 1ª. *, /, % 2ª. +, - Ex: 1. x+y;
- x-y;
- 2*nota + 10;
- tot/k - 40;
- y=9 % 4; 4.0 - Funções de entrada e saída Funções: i) cin >> nome-da-variável >> nome-da variável >>... Transfere os dados externos via teclado para as variáveis especificadas. Obs.: >> significa OPERADOR DE EXTRAÇÃO Ex.: cin >> anos; Cuidado os dados são separados de uma variável para outra através do espaço em branco.
4.2 - Saída cout << identificador <<... Onde: Identificadores são os nomes das variáveis e/ou mensagem. << operador de inserção. Exibe na tela o conteúdo de variáveis e/ou mensagens. Obs: A mensagem vem entre aspas duplas. Ex.: cout <<"A sua idade é : " << id; Tela id 18 A sua idade é : 18 5 - Manipuladores de tamanho de campos na impressão. O tamanho do campo é definido pelo arquivo iomanip.h e são os seguintes: 1 - setw - seleciona o tamanho do próximo campo a ser impresso. 2 - setprecision - define o numero de casas decimais a serem impressas para o número ponto flutuante ( float ). 3 - setfill - seleciona o caractere que deverá preencher as colunas em branco de um campo. Exemplos:
- com números inteiros #include <iostream.h> main( ) { int lap,bor,can,cad,fit; lap=45; bor=2345; can=420; cad=8; fit=13050; cout << "\n\n\n" // insere linhas cout << '\n' << "Borracha" << bor; cout << '\n' << "Lapis" << lap; cout << '\n' << "Canetas" << can; cout << '\n' << "Cadernos" << cad; cout << '\n' << "fitas" << fit; } #include <iostream.h> #include <iomanip.h> main( ) { int lap=45,bor=2345, can=420, cad=8, fit=13050; cout << "\n\n\n" // insere linhas cout << '\n' << "Borracha" << setw(12) << bor; cout << '\n' << "Lapis" <<setw(12) << lap; cout << '\n' << "Canetas" <<setw(12) << can; cout << '\n' << "Cadernos" <<setw(12) << cad; cout << '\n' << "fitas" <<setw(12) << fit; {}
- Preencher as colunas em branco com o caracter (.).
{ cout << "\n\n\n"; cout << "objeto"<<setw(12)<<"codigo"<<'\n'; cout <<'\n'<< "lapis"<<setw(12)<<"WQR"; cout << '\n'<< "borracha"<<setw(12)<<"ASO"; . . . } #include <iostream.h> #include <iomanip.h> #include <conio.h> void main(void) { float lap=4.875, bor = 234.542; cout<<"\n\n\n"; cout<<setprecision(2)<<setfill('.'); cout<<"\nlapis "<<setw(12)<<lap; cout<<"\nborracha "<<setw(12)<<bor; cout<<"\nAperte enter "; getch( ); return; } 6.0 - Funções Aritméticas
- sin(x)
- cos(x)
- atan(x) - arco-tangente de x
- sqrt(x) - raiz quadrada de x
- exp(x) - Nº. e elevado a x
- abs(x) - valor absoluto inteiro
- fabs(x) - valor absoluto real
- log(x) logaritmo
- log10 - logaritmo na base 10
- pow(x,y) - elevar x a y 7.0 - Operadores relacionais
- = = 3) > 5) > = 2)! = 4) < 6) < = 7.1 - O resultado de uma operação de dois valores pode ser:
- 0 (falso) ou 1 (verdadeiro) 7.2 - O resultado de uma operação lógica é um valor cujos bits são operados um a um de acordo com a álgebra de proposições. 7.3 - Operadores lógicos ! (negação) && (conjunção) || (disjunção) OBS: 1º. PORTA LÓGICA AND(&&) TABELA VERDADE:
