Notas Digitais: B.Tech (I Ano - Ii Sem) (2018-19)

PROGRAMAÇÃO ORIENTADA A OBJETOS
NOTAS DIGITAIS
B.TECH
(I ANO – II SEM)
(2018-19)
DEPARTAMENTO DE CSE & IT
LNVETOLEARN&LEARNTO
MALLA REDDY FACULDADE DE ENGENHARIA E TECNOLOGIA (

Instituição Autônoma – UGC, Governo da Índia)
Reconhecido sob 2(f) e 12 (B) do UGC ACT 1956 (Afiliado à JNTUH, Hyderabad, Aprovado pela AICTE -
Acreditado pela NBA & NAAC – Grau 'A' - Certificado ISO 9001:2015) Maisammaguda, Dhulapally (Post Via.
Hakimpet), Secunderabad – 500100, Estado de Telangana, Índia.
I Ano B.Tech II SEM L T/P/D C

4 1/-/- 3
(R18A0502) PROGRAMAÇÃO ORIENTADA A OBJETOS
Objectivos
• Ensinar ao aluno os conceitos de programação orientada a objetos e procedimentos
• Para diferenciar entre funções, classes e objetos
• Para aprender a sobrecarregar funções e operadores
• Para projetar aplicativos usando técnicas de gerenciamento de memória dinâmica
• Ensinar o aluno a implementar programação genérica e tratamento de exceções
Unidade I
Introdução à Programação Orientada a Objetos: Paradigma Orientado a Objetos - Diferenças entre
Programação Orientada a Objetos e Programação Orientada a Procedimentos, Conceitos Básicos de
Programação Orientada a Objetos, Encapsulamento, Herança e Polimorfismo, Benefícios da OOP,
Estrutura de um programa C++, namespace, Tipos de dados, tokens C++, Identificadores, Variáveis,
Constantes, Operadores, Estruturas de controle e Loops.
Unidade-II
Funções, Classes e Objetos:
Introdução de Classes, Definição de Classe, Definição de Membros, Objetos, Controle de Acesso,
Escopo de Classe, Operador de Resolução de Escopo, Funções embutidas, Alocação de Memória para
Objetos, Membros de Dados Estáticos, Funções de Membros Estáticos, Matrizes de Objetos, Objetos
como Argumentos de Função, Funções Amigas.
Unidade-III
Construtores, Destruidores, Herança:
Introdução a Construtores, Construtores Padrão, Construtores Parametrizados, Construtores de
Cópia, Múltiplos Construtores em uma Classe, Destruidores.
Herança:
Introdução à herança, Definição de classes derivadas, Herança única, Herança múltipla, Herança
multinível, Herança hierárquica, Herança híbrida.
Unidade-IV
Ponteiros, Funções Virtuais e Polimorfismo:
Introdução ao gerenciamento de memória, novo operador e operador de exclusão, Ponteiros para
objetos, Ponteiros para classes derivadas, Polimorfismo, Polimorfismo de tempo de compilação,
Polimorfismo de tempo de execução, Funções virtuais, Sobrecarga de função, Sobrecarga de
operador.
Unidade-V
Modelos e tratamento de exceções:
Introdução a Modelos, Modelos de Classe, Modelos de Classe com Vários Parâmetros, Modelos de
Função, Modelos de Função com Vários Parâmetros.
Tratamento de exceções:
Noções básicas de tratamento de exceções, tipos de exceções, mecanismo de manipulação de
exceções, mecanismo de lançamento e captura, relançamento de uma exceção, especificação de
exceções.
Resultados:
• Diferenciar programação orientada a objetos e programação processual.
• Para construir classes, funções e objetos
• Para implementar os construtores, destruidores e herança
• Desenvolver programas utilizando técnicas de gerenciamento dinâmico de memória
• Para aplicar manipulação de exceções e programação genérica.
Livros Didáticos:
1. Programação Orientada a Objetos com C++ por Balagurusamy
2. C++, The Complete Reference,4ª Edição, Herbert Schildt, TMH.
Referências:
1. Cartilha C++,3ª Edição, S.B.Lippman e J.Lajoie, Pearson Education.
2. A Linguagem de Programação C++,3ª Edição, B.Stroutstrup, Pearson Educ
UNIDADE -1
Conceitos de programação orientada a objetos: Paradigma orientado a objetos – diferenças entre

Programação Orientada a Objetos e Programação Orientada a Procedimentos, conceitos básicos de
Programação Orientada a Objetos, Encapsulamento, Herança e Polimorfismo. Benefícios da OOP . Estrutura
de um programa C++, namespace, tipos de dados, tokens C++, identificadores, variáveis, constantes,
operadores, estruturas de controle e loops.
Visão geral da linguagem C:

1. A linguagem C é conhecida como linguagem orientada à estrutura ou linguagem orientada a procedimentos
2. Emprega a abordagem de programação de cima para baixo onde um problema é visto como uma sequência de
tarefas a serem executadas.
3. Todo o código de programa de c pode ser executado em C++, mas converse muitos não ser possível
4. A sobrecarga da função e a sobrecarga do operador não são possíveis.
5. As variáveis locais podem ser declaradas apenas no início do bloco.
6. Os controles do programa são feitos por meio de saltos e chamadas para sub-rotinas.
7. Polimorfismo, encapsulamento e herança não são possíveis.
Para resolver os problemas, o problema é dividido em vários módulos. Cada módulo é um subprograma.
8. A propriedade de abstração de dados não é suportada pela linguagem orientada a procedimentos.
9. Os dados em linguagem orientada a procedimentos são abertos e podem ser acessados por qualquer função.
Visão geral da linguagem C++:

1. C++ pode ser considerado como uma versão incremental da linguagem c que consiste em todas as construções
de linguagem de programação com recursos recém-adicionados de programação orientada a objetos.
2. C++ é uma linguagem de programação orientada a estrutura (procedimento) e a objetos.
3. A extensão do arquivo do programa C++ é ". CPP"
4. Sobrecarga de função e sobrecarga do operador são possíveis.
5. As variáveis podem ser declaradas em linha, ou seja, quando necessário
6. Em c++, mais ênfase é dada aos dados em vez de procedimentos
7. Polimorfismo, encapsulamento e herança são possíveis.
8. A propriedade de abstração de dados é suportada pelo c++.
9. O acesso aos dados é limitado. Ele pode ser acessado fornecendo vários modos de visibilidade tanto para
dados quanto para funções de membros. lá, fornecendo segurança de dados por ocultação de dados
10. A vinculação dinâmica é suportada pelo C++
11. . Ele suporta todos os recursos da linguagem c
12.It pode ser chamado como uma versão incremental da linguagem C
Diferença entre Programação Orientada a Procedimentos (POP) e Programação Orientada a Objetos
(OOP)
Programação Orientada a Procedimentos Programação Orientada a Objetos

programa é dividido em pequenas partes
1
programa é dividido em partes chamadas objetos.
chamadas funções.
Não se dá importância aos dados , mas às Dá-se importância aos dados em vez de
2
funções e à sequência de ações a serem procedimentos ou funções, porque eles funcionam
realizadas. como um mundo real.
3 Segue Abordagem de cima para baixo. OOP segue Abordagem de baixo para cima.
OOP tem especificadores de acesso chamados
4 Não possui nenhum especificador de acesso.
Público, Privado, Protegido, etc.
Os dados podem mover-se livremente de Os objetos podem se mover e se comunicar uns
5
função para função no sistema. com os outros por meio de funções de membro.
Para adicionar novos dados e função em POP A OOP fornece uma maneira fácil de adicionar
6
não é tão fácil. novos dados e funções.
A maioria das funções usa dados globais para Em OOP, os dados não podem se mover facilmente
7 compartilhamento que podem ser acessados de função para função, ele pode ser mantido
livremente de função para função no sistema. público ou privado para que possamos controlar o
Ele não tem nenhuma maneira adequada para acesso
A OOPdos dados.
fornece ocultação de dados para fornecer
8
ocultar dados, por isso é menos seguro. mais segurança.
Na OOP, a sobrecarga é possível na forma de

9 A sobrecarga não é possível.
sobrecarga de função e sobrecarga do operador.
Exemplo de Orientação a Procedimentos

Exemplos de Programação Orientada a Objetos
10 As programações são: C, VB, FORTRAN, são: C++, JAVA, VB.NET, C#.NET.
Pascal.
Princípios( ou características) da programação orientada a objetos:

1. Encapsulação
2. Abstração de dados
3. Polimorfismo
4. Herança
5. Vinculação dinâmica
6. Transmissão de mensagens
Encapsulação: O empacotamento de dados e funções como uma única unidade é conhecido como
encapsulamento. Por padrão, os dados não são acessíveis ao mundo exterior e só são acessíveis por meio das
funções que são encapsuladas em uma classe. Prevenção de acesso direto de dados pelo programa é chamado de
ocultação de dados ou ocultação de informações
Abstração de dados :
A abstração refere-se ao ato de representar características essenciais sem incluir os detalhes ou
explicações de fundo. As classes usam o conceito de abstração e são definidas como uma lista de atributos como
tamanho, peso, custo e funções para operar sobre esses atributos. Eles encapsulam todas as propriedades
essenciais do objeto a ser criado. Os atributos são chamados como membros de dados, pois eles contêm dados e
as funções que operam nesses dados são chamadas como funções de membro.
As classes usam o conceito de abstração de dados, por isso são chamadas de tipo de dados abstratos
(ADT)
Polimorfismo: Polimorfismo vem das palavras gregas "poly" e "morfismo". "poli" significa muitos e "morfismo"
significa forma, ou seja, muitas formas. Polimorfismo significa a capacidade de assumir mais de uma forma. Por
exemplo, uma operação tem comportamento diferente em instâncias diferentes. O comportamento depende do
tipo de dados usados na operação.
Diferentes maneiras de alcançar o polimorfismo no programa C++:
1) Sobrecarga de função 2) Sobrecarga do operador
#include<iostream>
Usando namespace
DST; int main() {int a=4; a=a<<2;
cout<<"a="<<a<<endl;
retorno 0;
}
Herança: A herança é o processo pelo qual um objeto pode adquirir as propriedades de outro.
A herança é o conceito mais promissor de OOP, que ajuda a realizar o objetivo de construir software a partir de
peças reutilizáveis, em vez de codificar manualmente cada sistema do zero. A herança não só oferece suporte à
reutilização entre sistemas, mas também facilita diretamente a extensibilidade dentro de um sistema. A herança,
juntamente com polimorfismo e vinculação dinâmica, minimiza a quantidade de código existente a ser
modificado enquanto aprimora um sistema.
Quando o filho da classe herda o pai da classe, o filho da classe é referido como classe derivada
(subclasse) e o pai da classe como uma classe base (superclasse). Nesse caso, o filho da classe tem duas partes:
uma parte derivada e uma parte incremental. A parte derivada é herdada do pai da classe. A parte incremental é o
novo código escrito especificamente para o filho da classe.
Vinculação dinâmica:
Vinculação refere-se à vinculação da chamada de procedimento ao código a ser executado em resposta à
chamada. Vinculação dinâmica (ou vinculação tardia) significa o código associado a uma determinada chamada
de procedimento em não conhecido até o momento da chamada em tempo de execução.
Passagem de mensagem:
Um programa orientado a objetos consiste em um conjunto de objetos que se comunicam entre si.
Os objetos se comunicam entre si enviando e recebendo informações.
Uma mensagem para um objeto é uma solicitação para execução de um procedimento e, portanto, invocar
a função que é chamada para um objeto e gera resultado
Benefícios da programação orientada a objetos (OOPs)

> , ........................... . . Reutilização: Nos programas OOP, funções e módulos que são escritos por um usuário podem ser
reutilizados por outros usuários sem qualquer modificação.
Herança: Através disso podemos eliminar código redundante e estender o uso de classes existentes.
Ocultação de dados: O programador pode ocultar os dados e funções em uma classe de outras classes. Ele ajuda o programador
a construir os programas seguros.
Complexidade reduzida de um problema: O problema dado pode ser visto como uma coleção de objetos diferentes.
Cada objeto é responsável por uma tarefa específica. O problema é resolvido pela interface dos objetos. Essa técnica reduz
a complexidade do desenho do programa.
Fácil de manter e atualizar: A OOP facilita a manutenção e modificação do código existente, pois novos objetos
podem ser criados com pequenas diferenças em relação aos existentes. A complexidade do software pode ser
facilmente gerenciada.
Passagem de mensagens: A técnica de comunicação de mensagens entre objetos facilita a interface com sistemas externos.
Modificabilidade: é fácil fazer pequenas alterações na representação de dados ou nos procedimentos em

um programa OO. As mudanças dentro de uma classe não afetam nenhuma outra parte de um programa,
uma vez que a única interface pública que o mundo externo tem com uma classe é através do uso de
métodos.
ESTRUTURA BÁSICA DA LINGUAGEM C++ : O programa escrito em linguagem C++ segue essa estrutura
básica. A sequência de seções deve ser como estão na estrutura básica. Um programa C deve ter uma ou mais
seções, mas a sequência de seções deve ser seguida.
1. Seção de documentação
2. Seção de vinculação
3. Seção Definição
4. Seção de declaração global & declarações de classe
5. Definição da função de membro
6. Função principal
seção main() {
Seção Declaração Seção executável
1. SEÇÃO DE DOCUMENTAÇÃO: vem em primeiro lugar e é usado para documentar o uso de lógica
ou razões em seu programa. Ele pode ser usado para escrever o objetivo do programa, desenvolvedor e detalhes
lógicos. A documentação é feita em linguagem C com /* e */ . Tudo o que está escrito entre esses dois são
chamados de comentários.
2. SEÇÃO DE VINCULAÇÃO : Esta seção diz ao compilador para vincular determinadas
ocorrências de palavras-chave ou funções em seu programa aos arquivos de cabeçalho especificados nesta
seção.
por exemplo, #include<iostream>
usando namespace std;
faz com que o pré-processador adicione o conteúdo do arquivo IOSTREAM ao programa. Contém declarações para cout e cin.
>
Cout é um objeto predefinido que representa o fluxo de saída padrão. O operador << é um
operador de inserção, faz com que a cadeia de caracteres entre aspas duplas seja exibida na tela.
A afirmação cin>>n; é uma instrução de entrada e faz com que o programa aguarde que o usuário digite um
número. O número digitado é colocado na variável "n". O identificador cin é um objeto predefinido em C++ que
corresponde ao fluxo de entrada padrão. O operador >> é conhecido como operador de extração. Ele extrai o
valor do teclado e o atribui à variável de valor à direita.
3. SEÇÃO DE DEFINIÇÃO : Ele é usado para declarar algumas constantes e atribuir-lhes

algumas
valor. por exemplo, #define MAX 25
Aqui #define é uma diretiva do compilador que diz ao compilador sempre que o MAX é
encontrado no programa substituí-lo por 25.
4. SEÇÃO DECLARAÇÃO GLOBAL : Aqui, as variáveis e as diferenças de classe que são usadas ao
longo do programa (incluindo funções principais e outras) são declaradas de modo a torná-las globais (ou seja,
acessíveis a todas as partes do programa). Uma CLASSE é uma coleção de dados e funções que agem ou
manipulam os dados. Os componentes de dados de uma classe são chamados de membros de dados e os
componentes de função de uma classe são chamados de funções de membro
Uma classe ca também denominada como uma impressão azul ou protótipo que define a variável ou
funções comuns a todos os objetos de determinado tipo. É um tipo de dados definido pelo usuário
por exemplo,
Int I; Esta declaração é feita fora e antes de main()
5. SUBPROGRAMA OU SEÇÃO DE FUNÇÃO: Este tem todos os subprogramas ou as funções que o

nosso programa precisa.
exibição vazia()
{
cout<<"C++ é melhor que C";
}
PROGRAMA "C++‟ SIMPLES:
#include<iostream>
exibição vazia()
{
cout<<"C++ é melhor que C";
}
int main()
{
exibição()
retorno 0;
}
6. SEÇÃO DE FUNÇÃO PRINCIPAL: Ele diz ao compilador onde iniciar a execução a partir de main()
{
ponto do início da execução
}
A função principal tem duas seções
1. seção de declaração : Nela as variáveis e seus tipos de dados são declarados.
2. Seção executável ou seção de instruções: Esta tem a parte do programa que realmente executa a tarefa
que precisamos.
Espaço de nome:
namespace é usado para definir um escopo que pode conter identificadores globais.
ex:-namespace escopo para biblioteca padrão do C++.
Uma classe, funções e modelos são declarados dentro do namespace nomeado
std usando namespace std;-->directive pode ser usado.
Espaço de nome definido pelo usuário:

sintaxe para definir o espaço de nome é
namespace_name de namespace
{
declarações de variables.functions, classes etc...
}
ex:
#include<iostream>
Exemplo de namespace
{`
Int M;
Exibição vazia (int n)
{
cout<<"no namespace N="<<n<<endl;
}
}
usando exemplo de namespace;

int main()
{
int a=5;
m=100;
visor(200);
cout<<"M no espaço do nome da amostra:"<<amostra::m;
retornar 0;}
#include<iostream>
Essa diretiva faz com que o pré-processador adicione conteúdo do arquivo iostream ao programa. algumas
versões antigas do C++ usado iostream.h .if complier não suporta ANSI (American nation standard
institute) C++ em seguida, use o arquivo de cabeçalho iostream.h
TIPOS DE DADOS:
Um tipo de dados é usado para indicar o tipo de valor de dados armazenado em uma variável. Todos os
compiladores C suportam uma variedade de tipos de dados. Essa variedade de tipos de dados permite que
o programador selecione o tipo apropriado às necessidades do aplicativo, bem como da máquina. ANSI C
suporta as seguintes classes de dados
Tipos de dados primários:

tipo de dados 1.integer
2 Tipo de dados .character
3 Tipo de dados de ponto .float
4 . Tipo de dados booleanos
tipo de dados 5.void
tipo de dados inteiro:-
Esse tipo de dados é usado para armazenar números inteiros. Esses números não contêm a parte decimal. O tamanho do
inteiro depende do comprimento mundial de uma máquina (16 bits ou 32 bits). Em uma máquina de 16 bits, o intervalo de
valores inteiros é - 32.768 a +32.767.variáveis inteiras são declaradas pela palavra-chave int. C fornece controle sobre o
intervalo de valores inteiros e o espaço de armazenamento ocupado por esses valores por meio dos tipos de dados: short int,
int, long int em formulários assinados e não assinados.
Inteiros assinados: (máquina de 16 bits):

Um inteiro assinado usa 1 bit para o sinal e 15 bits para a magnitude do número
Um inteiro assinado usa 1 bit para sinal e 15 bits para a magnitude do número. (-2 15a +215-1).
Ex: conectado tx=100;
0 0 0 0 0 0 0 0 0 1 1 0 0 1 0 0
, । । .......
Bit assinado Magnitude
MSB (bit mais significativo)
100(10)=00000000001100100(2)
Representação do número negativo :
-100(10)=1111111110011100(2)
15 14 13 12 11 10 9 8 7 -1*2 +1*2 +1*2 +1*2 +1*2 +1*2 +1*2 +1*2

+1*2 +
6 5 4 3 2 1 0
0*2 +0*2 +1*2 +1*2 +1*2 +0*2 +0*2
= -32768+16384+8192+4096+2048+1024+512+256+128+0+0+26+8+4+0+0 =-
100(10)
Observação : bit assinado (MSB BIT): 0 representa inteiro positivo, 1 representa números negativos
Inteiros não assinados: inteiros não assinados usam todos os 16 bits para armazenar a magnitude. Armazena
números não tem nenhum sinal & O qualificador de tamanho e o intervalo do tipo de dados inteiro em um
computador de 16 bits são mostrados na tabela:
MEMÓRIA NECESSÁRIA
GAMA FORMATO
OU TAMANHO DO
TIPO DE DADO ARMAZENAMENTO EM BYTES DO
TURBO C GCC/ TURBO C ( 16 BITS) GCC ESPÉCIME
( 16 BITS) COMPILADORES (32 BITS)
EM LINUX (32 BITS)
int curto
-32768
ou -32768
2 2 Até 32767 %HD
Para 32767 (-2 até
assinado curto int +2 -1) (-2 até +2 -1)
int curto
0 a 65535 (0 a +2 -1) 0 a 65535 (0 a +2 -1)
ou
assinado curto int 2 2 %hu
-32768 -2.147.843.648 para

2 4
Para 32767 (-2 até 2.147.843.647 (-2 para +2
assinado int ou int %d ou %i
+2 -1) -1)
int não assinado 0 a 65535 0 a 4.294.967.295 (0 a 2 -1 )
2 4 (0 a +2 -1) %u
int longo ou
assinado int longo -2.147.843.648 até -2.147.843.648 até
4 4 2,147,843,647 2,147,843,647 %ld
31 31
(-2 a +2 -1) (-2 a +2 -1)
unsigned longo int 0 a 4.294.967.295 0 a 4.294.967.295 (0 a 2 -1 )
4 4 (0 a 2 -1 ) %lu
longo longo int ou -9223372036854775808
assinado longo Para
Não
longo suportado 8 ------- 9223372036854775807 (- %Ld
int 263 a +263-1)
Tipo de dados de caractere: (char)

Um único caractere pode ser definido como um tipo de dados de caractere. O tipo de dados de caractere ocupa um
byte de memória para armazenamento de caractere. Os qualificadores assinados ou não assinados podem ser
aplicados no tipo de dados char. char é a palavra-chave usada para declarar variáveis
O tamanho e o intervalo do tipo de dados de caracteres em máquinas de 16 bits ou 32 bits podem ser mostrados
abaixo
Tipo de dado MEMÓRIA NECESSÁRIA OU GAMA FORMATO DO ESPÉCIME

TAMANHO DE
ARMAZENAMENTO (em bytes)
char ou char assinado 1 -128 a 127(-2 7a 2 -1) %c
Caractere assinado não
1 0 a 256 (0 a 2 -1) %c
assinado
Tipos de ponto flutuante:
O número de ponto flutuante representa um número real com precisão de 6 dígitos que ocupa 4 bytes de memória.
As variáveis de ponto flutuante são declaradas pela palavra-chave float.
O tipo de dados de ponto flutuante duplo ocupa 8 bytes de memória, dando 14 dígitos de precisão. Estes também
são conhecidos como números de precisão dupla. As variáveis são declaradas pela palavra-chave double long double
refere-se a um tipo de dados de ponto flutuante que geralmente é mais preciso do que a precisão dupla.
O tamanho e o intervalo do tipo de dados de ponto flutuante são mostrados na tabela:
Tipo de dado Tamanho (memória) Gama especificador de
(palavra-chave) formato
Flutuar 32 bits (4 bytes) 3.4E-38T03.4E+38 %f
Dobrar 64 bits (8 bytes) 1.7E-308 até I.7E +308 %lf
duplo longo 80 bits (10 bytes) 3.4E-4932 até 1.1E+4932 Se
B Tipo de dados
oolean:- ou tipo de dados lógicos é um tipo de dados, com dois valores (geralmente denotados verdadeiro e
Booleano
falso), destinado a representar os valores verdade da lógica e álgebra booleana. Seu nome é uma homenagem a
George Boole, que definiu pela primeira vez um sistema algébrico de lógica em meados do século 19. O tipo de
dados booleano é o resultado primário de instruções condicionais, que permitem ações diferentes e fluxo de
controle de alteração, dependendo se uma condição booleana especificada pelo programador é avaliada como true
ou false.
C99 adicionou um tipo booleano (verdadeiro/falso) que é definido no cabeçalho <stdbool.h> A variável
booleana é definida pela palavra kkey bool ; Ex:
Bool B;
onde b é uma variável que pode armazenar true(1) de false (0)
Tipo de vazio
O tipo void não tem valores. Isso geralmente é usado para especificar o tipo de retorno de funções. O tipo da função dito ser
nulo quando não retorna nenhum valor para a função de chamada. Isso também é usado para declarar o ponteiro de propósito
geral chamado ponteiro nulo.
Tipos de dados derivados.
Os tipos de dados derivados são Matrizes, ponteiro e referências são exemplos para tipos de dados
derivados.
Tipos de dados definidos pelo usuário:
eles Os tipos de dados definidos pelo usuário são conhecidos como os tipos de dados definidos pelo usuário.
São eles: estrutura, união, classe e enumeração
C++ Tokens
IDENTIFICADORES: Identificadores são os nomes dados a vários elementos do programa, como variáveis,
funções e matrizes. Estes são nomes definidos pelo usuário que consistem em sequência de letras e dígitos.
Regras para declarar identificadores:
O primeiro caractere deve ser um alfabeto ou sublinhado.
> Deve ser composto apenas por letras, dígitos e sublinhado.
Os identificadores podem ter qualquer comprimento, mas apenas os primeiros 31 caracteres são significativos.
> Não deve conter espaço em branco ou espaço em branco.
Não devemos usar palavras-chave como identificadores.
> Letras maiúsculas e minúsculas são diferentes.
Exemplo: ab Ab aB AB são tratados de forma diferente
Exemplos de identificadores válidos:
a, x, n, n, SOMA, fato, grand_total, sum_of_digits, soma1
Exemplos de identificadores inválidos: $amount, ³num', grand-total, soma de dígitos, 4num.

$amount : Caractere especial não é permitido
Total: Hífen não é permitido.
soma de dígitos: espaços em branco entre as palavras não são permitidos.
4num : não deve começar com um número (o primeiro caractere deve ser uma letra ou sublinhado
Nota: Alguns compiladores de C reconhecem apenas os primeiros 8 caracteres; por causa disso, eles são
incapazes de distinguir identificadores com as palavras de comprimento superior a oito caracteres.
Variáveis:Um local de memória nomeado é chamado de variável.

OU
É um identificador usado para armazenar o valor de determinado tipo de dados na memória.
Como o nome da variável é identificador, usamos as seguintes regras que são iguais às do identificador
Regras para declarar nomes de
variáveis:
> O primeiro caractere deve ser um alfabeto ou sublinhado.
Deve ser composto apenas por letras, dígitos e sublinhado.
> Os identificadores podem ter qualquer comprimento, mas apenas os primeiros 31 caracteres são significativos.
Não deve conter espaço em branco ou espaço em branco.
> Não devemos usar palavras-chave como identificadores.

Letras maiúsculas e minúsculas são diferentes.
Os nomes das variáveis devem ser exclusivos no escopo fornecido
> Ex:int a,b,a;//está em válido
Int a,b;//é válido
Declaração de variável: A declaração de variável dá o nome para o local da memória e seu tamanho e
Especifica o intervalo de valores que pode ser armazenado nesse
Sintaxe:
local.
Nome da variável de tipo
de dados; a 10 2000
Ex:
int a=10; x 2.300000 5000
flutuação
KEYWORDS: x=2,3;
Existem certas palavras, chamadas palavras-chave (palavras reservadas) que têm um significado
predefinido na linguagem "C++‟ . Essas palavras-chave devem ser usadas apenas para a finalidade pretendida e
não como identificadores.
A tabela a seguir mostra as palavras-chave padrão "C++‟
Automático quebrar caso queimar Const continuar
inadimplência fazer dobrar mais enum Extern
flutuar durante Goto se int Longas
Registro retornar curto Assinado tamanho de estático
Struct interruptor typedef união Unsigned vazio
volátil enquanto .class amigo Novo excluir
este público privado Protegido Inline tentar
jogar pegar modelo
CONSTANTES:
Constantes referem-se a valores que não são alterados durante a execução de um programa.
As constantes podem ser divididas em duas categorias principais:
1. constantes primárias:
a) Constantes numéricas
Constantes inteiras.
Ponto flutuante (real)
Constantes. b) Constantes de caracteres
Constantes de caractere único Constantes de cadeia de caracteres
2. constantes secundárias:
Constantes de enumeração.
Constantes simbólicas.
Matrizes, sindicatos, etc.
Regras para declarar constantes:
1 . Vírgulas e espaços em branco não são permitidos dentro da constante.
2 . A constante pode ser precedida por menos (-) assinado, se necessário.
3 . O valor de uma constante deve estar dentro de seus limites mínimos de seu tipo de dados especificado.
Constantes inteiras: Uma constante inteira é um número com valor inteiro. Consiste em sequência de dígitos. As
constantes inteiras podem ser escritas em três sistemas numéricos diferentes:
1 . Inteiro decimal (base 10).
2 . Inteiro octal (base 8).
3 . Hexadecimal (base 16).
Constante inteira decimal: Consiste em conjunto de dígitos, de 0 a 9.
Declaração válida: 0, 124, -56, + 67, 4567 etc.
Declaração inválida: $245, 2.34, 34 345, 075.
23.345,00. é também uma declaração inválida.
Nota: Espaços incorporados, vírgulas, caracteres, símbolos especiais não são permitidos entre dígitos
Eles podem ser precedidos por um sinal opcional + ou ±.
Inteiro octal: Consiste em conjunto de dígitos, de 0 a 7.

Ex: 037, 0, 0765, 05557 etc. (representação válida)
É uma sequência de dígitos precedida por 0.
Ex: Representações inválidas
0394: o dígito 9 não é permitido (dígitos 0 a 7 apenas)
235: não começa com 0. (O número à esquerda deve ser 0).
Inteiro hexadecimal: Consiste em conjunto de dígitos, 0 a 9 e alfabetos A, B, C, D, E e F. Inteiro hexadecimal é

uma sequência de dígitos precedida por 0x ou 0X. Também podemos usar um através de f em vez de A para F.
Ex: 0X2, 0x9F, 0Xbcd, 0x0, 0x1. (Representações válidas)
Ex: Representações inválidas: 0af, 0xb3g, 0Xgh.
0af: não começa com 0x ou 0x.
0xb3g, 0xgh: caracteres ilegais como g, h. (apenas a a f são permitidos)
A magnitude (valor máximo) de uma constante inteira pode variar de zero a algum valor máximo que varia de um
computador para outro.
Os valores máximos típicos para a maioria dos computadores pessoais são: (máquinas de 16 bits)
Constante inteira decimal: 32767 (215-1)
Constante de inteiro Octal: 077777
Constante de inteiro hexadecimal: 0X7FFF
Nota: O maior valor que pode ser armazenado é dependente da máquina.
Constantes de ponto flutuante ou constantes reais : Os números com partes fracionárias são chamados de
constantes reais.
Estes são os números com base-10 que contém uma parte decimal ou expoente (ou ambos). Representação:
Esses números podem ser representados em notação decimal ou notação expoente (notação científica).
Notação decimal: 1234,56, 75,098, 0,0002, -0,00674 (notações válidas)
Notação expoente ou científica:
Forma geral: Mantissa e expoente
Mantissa: É um número real expresso em notação decimal ou uma notação inteira.
Expoente: É um número inteiro com um sinal opcional de mais (+) ou menos (-).
E ou e: A letra que separa a mantissa e a parte decimal.
Ex: (Notações válidas)
3
1,23456E+3 (1,23456×10 )
1
7,5098 e+1 (7,5098×10 )
-4
2E-4 (2×10 )
Essas notações exponenciais são úteis para representar números que são muito grandes ou muito grandes
pequeno. Ex: 0,00000000987 é equivalente a 9,87e-9
Constantes de caracteres:-
Constantes de caractere único: É caractere (ou qualquer símbolo ou dígito) entre aspas simples.
Ex: "a‟ "1‟ "*‟
Todas as constantes de caractere têm valores inteiros conhecidos como valores ASCII
ASCII:- ASCII significa American Standard Code for Information Interchange. Pronunciado ask-ee, ASCII é um código
para representar caracteres em inglês como números, com cada letra atribuída um número de 0 a 255.Os computadores só
podem entender números, então um código ASCII é a representação numérica de um caractere como 'a' ou '@' ou uma
ação de algum tipo. Um código SCII representa texto em computadores, equipamentos de comunicação e outros dispositivos
que usam texto. A maioria dos esquemas modernos de codificação de caracteres são baseados em ASCII, embora suportem
muitos caracteres adicionais. Abaixo está a tabela de caracteres ASCII e isso inclui descrições dos primeiros 32 caracteres
não imprimíveis.
Constantes de cadeia de caracteres ou literal de cadeia de caracteres:
Constante de cadeia de caracteres é uma sequência de zero ou mais caracteres entre aspas duplas.
Exemplo:
"MRCET" "12345" "*)(&%"
Sequências de escape ou constantes de caracteres de barra invertida
A linguagem C suporta alguns caracteres não imprimíveis, bem como barras invertidas ( \ ) que podem ser
expressas
como sequências de fuga. Uma sequência de escape sempre começa com barra invertida seguida por um ou mais
caracteres especiais.
Por exemplo, um novo caractere de linha é representado "\n" ou endl
Estes são usados na formatação da tela de saída, ou seja, a sequência de escape é usada em
funções de saída. Algumas sequências de fuga são dadas abaixo:
Sequência de fuga Personagem

"a' alerta sonoro
"b' espaço traseiro
"f feed de formulários
"n' nova linha
"e' guia horizontal
guia vertical
Citação simples
Aspas duplas
«\23 ponto de interrogação
"W Barra invertida
Não' Zero
OPERADORES E EXPRESSÕES
Um operador é um símbolo que representa uma operação específica que pode ser executada em dados. Um operando é o
objeto no qual uma operação é executada.
Combinando os operadores e operandos formamos uma expressão. Uma expressão é uma sequência de operandos e
operadores que se reduz a um único valor.
Os operadores C podem ser classificados como

1. Operadores aritméticos
2. Operadores relacionais
3. Operadores lógicos
4. Operadores de atribuição
5. Operadores de incremento ou decremento
6. Operador condicional
7. Operadores bit wise
8. operador unário
9. Operadores especiais
10. Operadores adicionais em c++
1. OPERADORES ARITMÉTICOS : Todos os operadores aritméticos básicos estão presentes no operador C.

significado
+ adicionar
- subtrair a
* multiplicação
/ divisão
% divisão de módulo(restante)
Uma operação aritmética envolvendo apenas operandos reais (ou operandos inteiros) é chamada de
aritmética real (ou aritmética inteira). Se uma combinação de aritmética e real é chamada de aritmética de modo
misto.
/*Programa C em Expressões Aritméticas Inteiras*/
#include<iostraem.h>
void principal()
{
Int A, B;
cout<"Digite quaisquer dois inteiros";
cin>>a>>b;
cout<<"a+b"<< a+b;
Cout<<"A-B"<< A-B;
Cout<<"A*B"<< A*B;
cout<<"a/b"<< a/b;
cout<<"a%b"<< a%b;
}
SAÍDA:
a+b=23
a-b=17
a*b=60
a/b=6
a% b=2
2. OPERADORES RELACIONAIS : Muitas vezes comparamos duas grandezas e, dependendo de sua

relação, tomamos certas decisões para essa comparação, usamos operadores relacionais.
operador significado
> é menor que

> é maior que
> = é menor ou igual a
> = é maior ou igual a
== é igual a
!= não é igual a
/* Programa C em operadores relacionais*/
#include<iostream.h>
void principal()
{
Int A,B;
CLRSCR();
cout<<"Digite a, b valores:";
cin>>a>>b;
Cout<<"A>B"<< A>B;
cout<<"a>=b"<< a>=b;
cout<<"a<b"<< a<b;
cout<<"a<=b"<< a<=b;
Cout<<"A==B"<< A==B;
cout<<"a!=b"<< a!=b;
}
SAÍDA:
Insira valores a, b: 5 9
a>b: 0 //falso
a<b: 1 //verdadeiro
a>=a: 1 //verdadeiro
a<=b: 1 //verdadeiro
a==b: 0 //falso
a!=b: 1 //verdadeiro
3 . OPERADORES LÓGICOS:
Dados lógicos: Um dado é chamado de lógico se transmite a ideia de verdadeiro ou falso. Em C++, usamos o tipo de dados
int para representar dados lógicos. Se o valor dos dados for zero, ele será considerado falso. Se for diferente de -zero (1 ou
qualquer inteiro diferente de 0) é considerado verdadeiro. O C++ tem três operadores lógicos para combinar valores lógicos e
criar novos valores lógicos:
Tabelas verdade para AND (&) e OR (operadores de ID : X Y X&Y X/Y

0 0 0 0
1 mesa rute tor NO I (!) operador: 0 1 0 1
x «X
0 1 1 0 0 1
1 0 1 1 Eu 1
Nota:O programa abaixo funciona no compilador que suporta os padrões C99
#include<stdbool.h>
int main()
{
Bool A,B;
/*lógico e*/
a=0;b=0;
Cout<<" A&&B "<< A&&B<<Endl;
a=0;b=1;
a=1;b=0;
a=1;b=1;
/*lógico ou*/
a=0;b=0;
Cout<<" a||b "<< a||B<<Endl;
a=0;b=1;
a=1;b=0;
a=1;b=1;
/*lógico não*/
a=0;
a=1;
retorno 0;
}
SAÍDA: 0&&0=0
0&&1=0
1&&0=0
1&&1=1
0||0=0
0||1=1
1||0=1 1||1=1 !0 =1 !1 =0
4 . OPERADOR DE ATRIBUIÇÃO:
A expressão de atribuição avalia o operando no lado direito do operador (=) e coloca seu valor na variável
à esquerda.
Nota: O operando esquerdo em uma expressão de atribuição deve ser uma única variável.
Existem duas formas de atribuição:
•Atribuição simples
•Atribuição composta
Atribuição simples:
Em expressões algébricas encontramos essas expressões.
Ex: a=5; a=a+1; a=b+1;
Aqui, o operando do lado esquerdo deve ser uma variável, mas não uma constante. A variável do lado
esquerdo deve ser capaz de receber um valor da expressão. Se o operando esquerdo não puder receber um
valor e atribuímos um a ele, obteremos um erro de compilação.
Atribuição composta:
Uma atribuição composta é uma notação abreviada para uma atribuição simples. Requer que o operando
esquerdo seja repetido como parte da expressão direita. Sintaxe: variável operator+=value
Ex:
A+=1; equivale a A=A+1;
Vantagens de usar operador de atribuição taquigráfica:

1. O que aparece do lado esquerdo não precisa ser repetido e, portanto, fica mais fácil escrever.
2. A declaração é mais concisa e fácil de ler.
3. A afirmação é mais eficiente.
O operador ++ adiciona um ao seu operando, onde como o operador - - subtrai um de seu operando. Esses operadores são
operadores unários e assumir a seguinte forma:
Operador Descrição
Os operadores de incremento e decremento podem
preceder ou seguir o operando. -—um Pré-incremento
Incremento/Decremento Postfix :( a++/a--) a++ Pós-incremento
No incremento pós-fixo (Decrement) o valor é —um Pré-decremento
incrementado (decremented) por um. Assim, o a++ tem o a— Pós-decremento
mesmo efeito que
Alguns dos operadores de atribuição de taquigrafia comumente usados são mostrados na tabela a seguir:
Instrução com operador de atribuição simples Declaração com operador taquigráfico
a=a+l a-=1
a=a-l a-=l
a=a*l a*=i
a=a/1 A-1
a=a% 1 a%=l
a=a*(n-l) a*=n+1
5.OPERADORES DE INCREMENTO (++) E DECREMENTO (--):
a=a+1; a--tem o mesmo efeito que a=a-1.
A diferença entre a++ e a+1 é, se ++ é após o operando, o incremento ocorre depois que a expressão é avaliada.
O operando em uma expressão postfix deve ser uma variável.
Ex1:
int a=5;
B=a++; Aqui o valor de B é 5. o valor de a é 6.
Ex2:
int x=4; y=x--; Aqui o valor de y é 4, o valor x é 3
Incremento/Decremento de prefixo (++a/ --a)
No incremento de prefixo (decremento) o efeito ocorre antes que a expressão que contém o operador seja avaliada. É o
inverso da operação postfix. ++a tem o mesmo efeito que a=a+1.
--a tem o mesmo efeito que a=a-1.
Ex: int b=4;
A= ++b;
Neste caso, o valor de b seria 5 e A seria 5.
Os efeitos do pós-fixo e do incremento de prefixo são os mesmos: a variável é incrementada por
1. Mas eles se comportam de forma diferente quando usados em expressões como mostrado acima. A execução desses
operadores é rápida quando comparada à instrução de atribuição equivalente.
int main()
{
int a=1;
int b=5;
++a;
--b;
Cout<<"B="<<B<<Endl;
cout<<"a="<<a++<<endl;
cout<<"b="<<b--<<endl;
Cout<<"B="<<B<<Endl;
retorno 0;
}
a=2
b=4
a=2
a=3
b=4
b=3
6 . OPERADOR CONDICIONAL OU OPERADOR TERNÁRIO:
Um operador ternário requer dois operandos para operar

Sintaxe:
void principal()
{
Int A, B,C;
cout<<"Insira os valores a e b:";
cin>>a>>b;
c=a>b?a:b;
cout<<"maior de a e b é "<<c;
}
Insira os valores a e b:1 5
maior de a e b é 5
7 . OPERADORES BIT WISE : C suporta operadores especiais conhecidos como operadores bit wise para
manipulação de dados no nível de bits. Eles não são aplicados para flutuar ou dobrar.
operador significado
& Bitwise E
^ Exclusivo Bitwise OU
<< Desvio para a esquerda
>> Desvio para a direita
~ o complemento de um
Operador Bitwise AND (&)
O operador bit a bit AND é um operador binário que requer dois operandos integrais (caractere ou inteiro). Ele faz uma
comparação bit a bit como mostrado abaixo:
Primeiro Bit do Segundo bit do Opel & Opel
Operando
0 operando
0 0
0 1 0
1 0 0
1 1 1
Operador OR bit a bit ( |)

O operador OR bit a bit é um operador binário que requer dois operandos integrais (caractere ou inteiro). Ele
faz uma comparação bit a bit como mostrado abaixo:
Primeiro Bit do Segundo bit do operando Opel | Opel
Operando
0 0 0
0 1 1
1 0 1
1 1 1
Bitwise EXCLUSIVE OU operador ( A )

O operador bit a bit EXCLUSIVE OR é um operador binário que requer dois operandos integrais (caractere ou
inteiro). Ele faz uma comparação bit a bit como mostrado abaixo:
Primeiro Bit do Segundo bit do operando Opel A Opel
Operando
0 0 0
0 1 1
1 0 1
1 1 0
Operadores de turno
Os operadores de deslocamento movem bits para a direita ou para a esquerda. Estes são de dois tipos: . •Deslocamento
bit a bit do operador para a direita
. •Deslocamento bit a bit do operador para a esquerda
Operador de deslocamento bit a bit para a direita
É um operador binário que requer dois operandos integrais. O primeiro operando é o valor a ser deslocado e o segundo
operando especifica o número de bits a serem deslocados. Quando os bits são deslocados para a direita, os bits na
extremidade mais direita são excluídos e um zero é inserido no bit MSB.
void principal()
{
int x, deslocamento;
cout<<"Digite um número:");
cin>>x;
cout<<"entrar agora muitas vezes para a direita deslocar: ";
cin>>shift;
cout<<"Antes do deslocamento para a direita:"<<x;
x=x>>shift;
cout<<"Após o deslocamento à direita:"<<x;
}
Run1:
Digite um número:8
Digite agora muitas vezes para a direita Shift:1
Antes do deslocamento para a direita:8
Após o deslocamento à direita:4
Explicação: O número introduzido através do teclado como entrada é 8 e o seu número binário correspondente é
1000...................................................................................................
0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0
15 14 13 12 11 10 9 876543 21 0
Após a execução do programa, os dados de entrada x devem ser deslocados por 2 bits para o lado direito. A
resposta em forma binária seria a seguinte:
0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0
15 14 13 12 11 10 9 876543 21 0
O operador de deslocamento à direita divide o número dado por uma potência de 2. Se mudarmos um número
binário dois lugares para a direita, estamos dividindo o número dado por 4 (2').
Operador de deslocamento bit a bit para a esquerda
É um operador binário que requer dois operandos integrais. O primeiro operando é o valor a ser deslocado e
o segundo operando especifica o número de bits a serem deslocados para a esquerda.
Quando os bits estão se deslocando para a esquerda, os bits na extremidade mais esquerda são excluídos.
Ex: int a=2;

a«=3;
Deslocar para a esquerda é o oposto do operador de deslocar para a direita. O operador de deslocamento
para a esquerda multiplica o número dado por uma potência de 2. Se deslocarmos um número binário três
lugares para a esquerda, estaremos multiplicando o número dado por 8 (23).
Complemento de um ou Bitwise NÃO
O bit bit NOT, ou complemento, é uma operação unária que executa negação lógica em cada bit. formando o
complemento do valor binário dado. Dígitos que eram 0 se tornam I, e vice-versa.
Ex: NÃO 0111 (decimal 7) = 1000 (decimal 8)
Em C, t o operador bit a bit NOT é (til). Tabela verdade:
Valor da expressão ~Expressão
0 1
1 (diferente de zero) 0
Nota: O operador de complemento (Bitwise NOT) de um é um operador Logical NOT de forma diferente.
Usamos este operador no processo de codificação e decodificação.
8.5 OPERADORES PECIAL
Esses operadores que não se encaixam em nenhuma das classificações acima são ,(vírgula), sizeof, operadores de
ponteiro (& e *) e operadores de seleção de membros (. e ->). O operador vírgula é usado para vincular
expressões relacionadas.
O operador SIZEOF:
Ele retorna o número de bytes ocupados pelo operando. O operando pode ser uma variável, uma constante
(valor de dados) ou um qualificador de tipo de dados.
Ex: int a. c, f, d;
c=tamanhode(a); aqui c=2, o operador sizeof retorna o tamanho da variável a que é do tipo int f=sizeof(long
double); o valor f é 10, que é o tamanho do qualificador duplo longo tipo d=sizeof(23.345); O valor d é 4 , que
é o tamanho do valor da constante float
O tamanho do operador é normalmente usado para determinar o comprimento de matrizes e estruturas. Ele
também é usado para alocar espaço dinamicamente para a variável s durante a execução de um programa.
O operador de vírgula (,)
O operador vírgula pode ser usado para vincular a expressão relacionada de expressões é avaliada da esquerda
para a direita e o valor da expressão combinada.
Ex: a=(x=10, y=20, x+y);
Primeiro atribui o valor 10 a x, depois atribui 20 a y e fina

Tem a menor precedência entre todos os operadores.
Usamos operador vírgula em instruções de loop e declaraticas do mesmo tipo.
Operador Descrição
4- Unário mais
9.OPERADOR UNARY: operador que opera em - Unário menos
operando único é chamado operador unário — Incremento
— Decréscimo
& Endereço
— Os complementam
Tamanho do Tamanho do operador
Tipo Fundição de tipos
Operadores em c++: Todos os operadores acima da linguagem c também são válidos em c++. Os novos
operadores introduzidos no c++ são:
Sno Operador Símbolo

1. Operador de resolução de escopo
2. Ponteiro para um declarador de ::*
3. membro
Ponteiro para operador membro ->*,->
4. Ponteiro para operador membro .*
5. Novo Operador de alocação de memória
6. excluir Operador de liberação de memória
7. Endl Operador de alimentação de linha
8. setw Operador de largura de campo
9. inserção <<
10. Extração >>
8.6 Operador de resolução de copa:

Âmbito:-A visibilidade ou disponibilidade de uma variável em um programa é chamada de escopo. Há dois tipos
de escopo. i)Âmbito local ii)Âmbito global
Escopo local: a visibilidade de uma variável é local para a função na qual ela é declarada.
Escopo global: visibilidade de uma variável para todas as funções de
um operador de resolução de escopo do programa em ": :" .
Isso é usado para acessar variáveis globais se as mesmas variáveis forem declaradas como locais
e PROGRAMA GLOBAL1.2:-
int a=5;
void principal()
{
int a=10;
cout<<"Local a="<<a<<endl;
cout<<"Global a="<<::a<<endl;
}
Resultado esperado:
Local a=10
Global a=5
Operador de desreferenciação de membros:-
membro para operador membro
2. Ponteiro ->*,->
Ponteiro para um declarador de membro ::*
Esse operador é usado para declarar um ponteiro para o membro da classe #include<iostream.h>
Amostra de classe
{público:
Int X;
};
int main()
{ amostras; objeto
int exemplo: :*p;//pointer decleration s.*p=10; correto
Cout<<S.*P;
} Saída: 10
2.Ponteiro para operador membro ->*
Exemplo de classe #include<iostream.h>
{
público:
Int X;
exibição vazia()
{
cout<<"x="<<x<<endl;
}
};
int main()
{
amostras; objeto
amostra *ptr;
int amostra::*f=&amostra::x;
s.x=10;
ptr=&s;
COUT<<PTR->*F;
ptr->display();
}

Amostra de classe
{
público: int x;
};
int main()
{
amostras; objeto
int exemplo: :*p;//pointer decleration
s.*p=10; correto
Cout<<S.*P;
}
Manipuladores:
Os manipuladores são os operadores usados para formatar os dados que devem ser exibidos na tela. Os
manipuladores mais utilizados são endl e setw
endl:-é usado na instrução de saída e insere um feed de linha. É semelhante ao novo caractere de linha ("\n")
ex: cout<<"a=2"<<endl;
cout<"nome=sunil"<<endl;
Saída:
a=2
nome=sunil
setw:-
Este manipulador permite uma largura especificada para um campo que deve ser impresso na tela
e por padrão o valor impresso é justificado corretamente. Esta função está disponível no arquivo de cabeçalho
iomanip.h
#include<iomanip.h>
int main()
{
int s=123;
cout<<"s="<<setw(10)<<s ;
}
saída
s= 123
Operadores de inserção (<<) e extração (>>):
os operadores são usados com objetos de saída e entrada
ex:
cout<<"Digite n";
cin>>n
Instruções de controle:-O fluxo de execução de instruções em um programa é chamado de controle. A

instrução Control é uma instrução que controla o fluxo de execução do programa. As instruções de controle são
classificadas nas seguintes categorias.
1.Instruções de controle sequencial
2.Instruções de controlo condicional
(tipo) expressão;
3.Declarações de controlo incondicional Ou
1.Sequencial Controle Declarações:- tipo (expressão); Instruções de controle
Declarações Garante Isso o sequencial(ou
declarações) são executadas na mesma ordem em que
eles aparecem no programa. ou seja, por inadimplência sistema
Executa as instruções na ordem do programa. em sequencial
2.Declarações de controlo condicional:Instruções que são executadas quando uma condição é verdadeira.
Essas afirmações são divididas em três categorias. eles são
1.Declarações de tomada de decisão
2.Mudar a instrução de controle de caso ou
3.Instruções ou repetições de controle de malha
1 . Declarações de tomada de decisão:- Estas declarações são usadas para controlar o fluxo de execução de
um programa, tomando uma decisão dependendo de uma condição, por isso são nomeadas como declarações de
tomada de decisão.
As declarações de tomada de decisão são de quatro tipos:
1. simples se
2.se mais
3.nested se mais
4.1 f outra escada
1.51 Instrução MPLE IF: Se a expressão de teste for True, a instrução if executa instruções que imediatamente
se seguem
Sintaxe:
If(expressão de teste)
Lista de depoimentos;
/*maior de dois números*/

#include<stdio.h>
int main()
{
Int A,B;
cout<<"Digite quaisquer dois inteiros:";
cin>>a>>b;
se(a>b)
cout<<"A é maior que B\n A="<<a;
se(b>a)
cout<<"B é maior que A\n A="<<b;
retorno 0;
}
2 . instrução if –else:
Se a expressão de teste for true, bloco de instruções a seguir se forem executadas e se a expressão de
teste for false, então as instruções em else block serão executadas if (expressão de teste)
{
bloco de enunciados1;
}
mais
{
bloco de enunciados2;
}
/*maior de dois números*/
int main()
{
Int A,B;
cout<<"Digite quaisquer dois inteiros:";
cin>>a>>b;
se(a>b) cout<<"A for maior que B\n A="<<a;
cout<<"B é maior que A\n A="<<b;

mai
s retorno 0;
3 . Aninhamento de instruções if-else it também é possível aninhar uma instrução if dentro de outra. Háuma série de decisões a
serem tomadas.
Instrução If –else colocada dentro de outra instrução if else Sintaxe:
If(expressão de teste) {If(expressão de
teste) { //instruções } else {
//instruções } } else
{If(expressão de teste) { //instruções }
else { //instruções }
} /*maior de três números*/
#include<conio.h> int main() { int a,b,c;
cout<<"Digite a,b,c valores:";
cin>>a>>b>>c;
se(a>b) {
se(a>c) {
cout<<"A ia
maior entre
três números\
n"; cout"A=
"<<a;
} else {
cout<<"C ia
maior entre
três números\
n"; cout<<"c= "<<c;
} } else {if(b>c) {
cout<<"B ia maior entre três números\n"; cout<<"B="<<b;
}
mais
{
cout<<"C ia maior entre três números\n";
cout<<"c="<<c;
}
}
getch();
retorno 0;
}
4.1 f outra escada
if(condição1)
enunciado1;
senão se(condição2)
afirmação 2;
senão se(condição3)
afirmação n;
mais
instrução padrão.
afirmação-x;
O aninhamento do if-else depende das condições com as quais temos que lidar.
A condição é avaliada de cima para baixo.se uma condição for verdadeira, a instrução associada a ela será executada.
Quando todas as condições se tornarem falsas, a parte final que contém instruções padrão será executada.
void principal()
{
Int Per;
cout<<"Entrar
porcentagem"; cin>>per;
se(per>=80)
cout<<"Seguro
Distinção"<<endl; senão se(per>=60)
cout<<"Secured First
Divisão"<<endl; senão se(per>=50)
cout<<"Seguro
Segunda Divisão"<<endl;
senão se(per>=40)
cout<<"Seguro
Divisão"<<endl; Tercei
mais ro
cout<<"Falhar"<<endl
A INSTRUÇÃO SWITCH ou SELEÇÃO MULTIDIRECIONAL :

Além da seleção bidirecional, a maioria das linguagens de programação fornece outro conceito de seleção conhecido como
seleção multidirecional. A seleção multiway escolhe entre várias alternativas. C tem duas maneiras diferentes de
implementar a seleção multidirecional: a instrução switch e a construção else-if
Se por suposição temos mais de uma opção válida para escolher, então podemos usar a instrução switch
no lugar das instruções if.
switch(expressão)
{.
valor do caso-1:
bloco-1
quebrar;
Valor do caso-2:
bloco-2
quebrar;
inadimplência:
bloco padrão;
/*programa para simular uma calculadora simples */ #include<iostream.h>

int main()
{
flutuar a,b;
char opr;
cout<<"Digite o número 1 do operador2 : ";

cin>>a>>oper>>b;
switch (opr)
{
Processo '+':
cout<<"Soma : "<<(a + b)<<endl;
quebrar;
caso '-': cout<<"Diferença: "<<(a -b)<<endl;
quebrar;
caso '*': cout<<"Produto : "<<a * b<<endl;
quebrar;
processo '/': cout<<"Quociente :"<<(a / b)<<endl;
quebrar;
padrão: cout<<"Operação inválida!"<<endl;
}
retorno 0;
}
Instruções ou repetições de controle de malha:

Um bloco ou grupo de instruções executadas repetidamente até que alguma condição seja satisfeita é
chamado de Loop. O grupo de instruções incluído na chave é chamado de bloco ou instrução composta.
Temos dois tipos de estruturas de looping.
Uma condição em que a condição é testada antes de entrar no bloco de instruções chamado controle de entrada.
O outro em que a condição é verificada na saída chamada loop controlado de saída.
As instruções de loop podem ser divididas em três categorias, conforme indicado abaixo:
1 Instrução de loop .while
2 Instrução .do while loop
3 Instrução de loop .for
1 . ENQUANTO DECLARAÇÃO:
While(condição de teste)
{
corpo do laço
}
É um loop de entrada controlada. A condição é avaliada e, se for
verdadeira, o corpo do loop é executado. Após a execução do corpo a
condição é novamente avaliada e se é verdadeiro corpo é executado mais
uma vez. Isso continua até que a condição de teste se torne falsa.
c programa para encontrar a soma de n números naturais */

int main()
{
int i = 1,soma = 0,n;
cout<<"Digite N"<<end;
cin>>n;
enquanto(i<=n)
{
soma = soma + i;
i = i + 1;
}
cout<<"Soma dos primeiros"<<n<"números naturais é:"<<soma<<endl; retorno 0;

}
2 . FAZER ENQUANTO AFIRMAR:
tlo-while — (Saída controlada)

O loop while não permite que o corpo seja executado se a condição de teste for false. O fazer enquanto
é um loop de saída controlada e seu corpo é executado pelo menos uma vez.
fazer
{
corpo
}while(condição de teste);
/*c programa para encontrar soma de n números naturais */

#include<stdio.h>
int main()
{
int i = 1,soma = 0,n;
cout<<"Digite N"<<endl;
cin>>n
do{
soma = soma + i;
i = i + 1;
} enquanto(i<=n);
cout<<"Soma dos primeiros"<< n<<" números naturais
é:"<<soma; retorno 0;
}
Nota: se a condição de teste for falsa. antes que o loop esteja sendo executado, em seguida, While loop executa zero
número de vezes onde as do--enquanto executa uma vez
3.FOR LOOP: É também uma malha de controle de entrada que fornece uma estrutura
mais concisa
Sintaxe:
for(inicialização; expressão de teste; incremento/decremento) {
Declarações;
}
Pois a instrução é dividida em três expressões, cada uma é
separada por ponto-e-vírgula;
1.A expressão de iniciação é usada para inicializar variáveis
2.A expressão de teste é responsável por continuar o loop. Se
for verdadeiro, o fluxo de controle do programa entra no loop
e executa o bloco de instruções associadas a ele. Se a
expressão de teste for falsa, o loop termina 3.a expressão de
incremento/decremento consiste no operador de incremento
ou decremento Esse processo continua até que a condição de
teste seja satisfeita.

#include<stdio.h>
int main()
{
int i ,soma = 0,n;
cout<<"Digite N";
cin>>n;
para(i=1;i<=n;i++)
{
soma = soma + i;
}
cout<<"Soma dos primeiros"<<n<<" números naturais é:%d"<<soma; retorno 0;
Loops aninhados:A gravação de uma instrução de controle de loop em outra instrução de controle de loop é
chamada de instrução de loop aninhado
Ex:
para(i=1;i<=10;i++)
for(j=1;j<=10;j++) cout<<i<<j;
/*programa para imprimir números primos até um determinado número*/

#include<stdio.h>
#include<conio.h>
void principal()
{
int n,i,fato,j;
CLRSCR();
cout<<"digite o número:";
cin>>n
para(i=1;i<=n;i++)
{fato=0;
ESTE LOOP MARCARÁ UM NÃO PARA SER O NÚMERO PRINCIPAL. OU
NÃO. para(j=1;j<=i;j++)
{
if(i%j==0) fato++;
}
if(fato==2)
cout<<i<<"\t";
}
getch( );
}
Saída:
Digite o número : 5
2 35
Instruções de controle incondicional:

Instruções que transferem o controle de uma parte do programa para outra parte
incondicionalmente Diferentes declarações incondicionais são
1) goto
2) quebra
3) continuar
1.goto :- A instrução goto é usada para ramificação incondicional ou transferência da execução do
programa para a instrução rotulada.
A instrução goto para ramificar incondicionalmente de um ponto para outro no programa. O goto requer uma
etiqueta para identificar o local onde o ramo deve ser feito. Um rótulo é qualquer nome de variável válido e
deve ser seguido por dois pontos (;). A etiqueta é colocada imediatamente
antes da declaração para onde o controlo deve ser transferido. A forma geral de goto é mostrada
abaixo:
rótulo etiqueta:
goto; declaração;
etiqueta:
declaração rótulo
; goto;
Salto para a frente Salto para trás
O rótulo: pode estar em qualquer lugar do programa antes ou depois do rótulo goto; declaração.
Se o rótulo: for colocado após o rótulo goto;, algumas instruções serão ignoradas e o salto é conhecido como
salto para frente.
Se o rótulo: é colocado antes do rótulo goto; Um loop será formado, algumas instruções serão executadas
repetidamente. Tal salto é conhecido como salto para trás.

#include<stdio.h>
int main()
{
int i ,soma = 0,n;
cout<<"Digite N";
cin>>n;
i=1;
L1:
soma = soma + i;
i++;
se(i<=n) ir para L1;
cout<<"Soma dos primeiros números naturais "<<n<" é"<<soma; retorno 0;

break:-quando uma instrução break é encontrada dentro de um loop, loop é
imediatamente encerrado e o programa continua com as instruções imediatamente após
loop
#include<stdio.h>
int main()
{
int i ,soma = 0,n;
cout<<"Digite N";
cin>>n;
i=1;
L1:
soma = soma + i;
i++;
se(i>n) quebrar;
Goto L1;
cout<<"Soma dos primeiros"<<n<<"números naturais é: "<<soma; retorno 0;

}
Continuar:Ele é usado para continuar a iteração da instrução loop ignorando as instruções

após a instrução continue. Isso faz com que o controle vá diretamente para a condição de teste
e, em seguida, continue o loop.
/*c programa para encontrar a soma de n números positivos lidos a partir do teclado*/
#include<stdio.h>
int main()
{
int i ,soma = 0,n,número;
cout<<Digite N";
cin>>n;
para(i=1;i<=n;i++)
{
cout<<"Digite um número:";
cin>>número;
se(número<0) continuar;
soma = soma + número;
}
cout<<"Soma de"<<n<<" números é:"<<soma;
retorno 0;
}
UNIDADE -2
Funções, Classes e Objetos:

Introdução de classes, definição de classe, definição de um membro, objetos, controle de acesso,
Escopo de classe,Operador de resolução de escopo,Funções embutidas,Alocação de memória para objetos,
Membros de dados estáticos, Funções de membro estático, Matrizes de objetos, Objetos como argumentos de
função,Funções de amigo.
Introdução da aula:
Uma abordagem de programação orientada a objetos é uma coleção de objetos e cada objeto consiste em
estruturas de dados e procedimentos correspondentes. O programa é reutilizável e mais sustentável.
O aspecto importante em oop é uma classe que tem sintaxe semelhante à de estrutura.
classe: É uma coleção de dados e funções de membro que manipulam dados. Os componentes de dados da
classe são chamados de membros de dados e as funções que manipulam os dados são chamadas de funções de
membro.
Também pode ser chamado de blue print ou protótipo que define as variáveis e funções comuns a todos
os objetos de determinado tipo. Também é conhecido como tipo de dados definido pelo usuário ou ADT (tipo
de dados abstrato) Uma classe é declarada pela classe de palavra-chave.
Sintaxe:-
classe class_name {
Especificador de acesso:
Declarações variáveis;
Especificador de acesso:
declarações de função;
};
Controle de acesso:
Especificador de acesso ou modificadores de acesso são os rótulos que especificam o tipo de acesso
dado aos membros de uma classe. Eles são usados para ocultar dados. Estes também são chamados de modos de
visibilidade. Existem três tipos de especificadores de acesso
1. privado
2.público
3. protegido
1. privado:
Se os membros de dados forem declarados como acesso privado, eles não poderão ser acessados de
outras funções fora da classe. Ele só pode ser acessado pelas funções declaradas dentro da classe. É declarado
pela palavra-chave "privado‟ .
2.public:
Se os membros de dados forem declarados acesso público, eles poderão ser acessados de outras funções
fora da classe. É declarado pela palavra-chave "público".
3. protegido: O nível de acesso da declaração protegida situa-se entre o público e o privado. Este especificador
de acesso é usado no momento da herança
Nota:-
Se nenhum especificador de acesso for especificado, ele será tratado por padrão como privado
O especificador de acesso padrão da estrutura é público onde como o de uma classe é "privado"
Exemplo:
aluno da turma
{
privado : int roll;
nome do char[30];
público:
void get_data()
{
cout<<"Digite o número e o nome do rolo": cin>>roll>>name;
}
void put_data()
{
cout<<"Número do rolo:"<<roll<<endl;
cout<<"Nome :"<<nome<<endl;
}
};
Object:-Instância de uma classe é chamada object.
Sintaxe:
class_name object_name;
Ex:
estudantes;
O acesso ao operador members:-d ot é usado para acessar membros da classe
Object-name.function-name(argumentos reais);
Ex:
s.get_data();
s.put_data();
Nota:
1 . Se o especificador de acesso não for especificado na classe, o especificador de acesso padrão será
privado
2 . Todas as funções de membro devem ser declaradas como públicas se não estiverem acessíveis fora
da classe. Objeto:
A instância de uma classe é chamada de objeto.
Sintaxe:
Class_name nome do objeto;
Exemplo:
estudantes;
no exemplo acima, s é o objeto. É uma entidade em tempo real que pode ser usada
Escrever um programa para ler dados de um aluno
#include<iostream>
aluno da turma
{
privado:
rolo int;
nome do char[20];
público:
void getdata()
{cout<<"Digite o número do rolo:";
cin>>roll;
cout<<"Digite o nome:";
cin>>nome;
}
void putdata()
{cout<<"Roll no:"<<roll<<endl;
cout<<Nome:"<<nome<<endl;
}
};
int main()
{
estudantes;
s.getdata();
s.putdata();
returm 0;
}
Operador de Resolução de Escopo:
Âmbito:-A visibilidade ou disponibilidade de uma variável em um programa é chamada de
escopo. Há dois tipos de escopo. i)Âmbito local ii)Âmbito global
Escopo local: a visibilidade de uma variável é local para a função na qual ela é declarada.
Escopo global: visibilidade de uma variável para todas as funções de um programa
Operador de resolução de escopo em "::" .
Isso é usado para acessar variáveis globais se as mesmas variáveis forem declaradas como
locais e globais
int a=5;
void principal()
{
int a=1;
cout<<"Local a="<<a<<endl;
cout<<"Global a="<<::a<<endl;
}
Escopo da classe:
Operador de resolução de escopo(::) é usado para definir uma função fora de uma classe.
#include <iostream>
Amostra de classe
{
público:
saída void(); declaração de função
};
definição de função fora do
classe void sample::output() {
cout << "Função definida fora da classe.\n";
};
int main() {
amostra obj;
obj.output();
retorno 0;
}
Saída do programa:
Função definida fora da classe.
Escrever um programa para localizar a área do retângulo

retângulo de classe
{
Int L,B;
público:
nulo get_data();
área vazia();
};
retângulo vazio::get_data()
{
cout<<"Digite o comprimento do retângulo";
cin>>L;
cout<<"Entrar na largura do retângulo";
cin>>B;
}
retângulo int::area()
{
retorno L*B;
}
int main()
{
retângulo r;
r.get_data();
cout<<"Área do retângulo é"<<r.area();
retorno 0;
}
FUNÇÕES EM LINHA:
Definição:
Uma função embutida é uma função que é expandida na linha quando é chamada. A expansão em linha
torna um programa executado mais rapidamente porque a sobrecarga de uma chamada de função e
retorno é eliminada. Ele é definido usando a palavra-chave " inline"
Necessidade de função em linha:

> • ,, , Um dos objetivos do uso de funções em um programa é economizar algum espaço de memória, o que se torna apreciável
quando uma função provavelmente será chamada muitas vezes.
Toda vez que uma função é chamada, leva muito tempo extra na execução de uma série de instruções para tarefas
como pular para a função, salvar registros, empurrar argumentos para a pilha e retornar à função de chamada.
>
Quando uma função é pequena, uma porcentagem substancial do tempo de execução pode ser gasta em tais
despesas gerais.
Uma solução para esse problema é usar definições de macro conhecidas como macros. As macros de
pré-processador são populares em C. A principal desvantagem com macros é que elas não são realmente
funções e, portanto, a verificação de erros usual não ocorre durante a compilação.
C++ tem solução diferente para esse problema. Para eliminar o custo de chamadas para pequenas
funções, o C++ propõe um novo recurso chamado função embutida.
Formulário Geral:
cabeçalho de função embutido
{
corpo funcional;
Eg:
Flutuador em linha Mul(Float X, Float Y)
{
retorno (x*y);
}
div duplo em linha (duplo p, duplo q)
{
retorno (p/q);
}
int main()
{
flutuação a=12,345;
flutuação b=9,82;
Cout<<mul(a,b);
Cout<<Div(A,B);
retorno 0;
}
Propriedades da função embutida:
1.A função embutida envia solicitação, mas não um comando para o compilador
2.Compilador meu servir ou ignorar a solicitação
3. se a função tem muitas linhas de código ou se tem lógica complicada, então é executada como função
normal
Situações em que o inline não funciona:
>
Uma função que está retornando valor , se ele contém loop de switch ou ambos, então é tratada como função normal.
>
Se uma função não está retornando nenhum valor e contém uma instrução de retorno, então ela é tratada como função
normal
>
Se a função contém variáveis estáticas, então ela é executada como função normal
>
Se a função embutida é declarada como função recursiva, então ela é executada como função
normal.
Alocação de memória para objetos: A memória para objetos é alocada quando eles são declarados, mas não
quando a classe é definida. Todos os objetos em uma determinada classe usam as mesmas funções de membro.
As funções de membro são criadas e colocadas na memória apenas uma vez quando são definidas na definição
de classe
MEMBROS ESTÁTICOS DA CLASSE
Membros de dados estáticos

Funções de membro estático
Membros de dados estáticos:
Um membro de dados de uma classe pode ser qualificado como estático. Uma variável de membro estático
tem certas características especiais:
Ele é inicializado como zero quando o primeiro objeto de sua classe é criado. Nenhuma outra inicialização
é permitida.
Apenas uma cópia desse membro é criada para a classe inteira e é compartilhada por todos os objetos dessa classe, não
importa quantos objetos sejam criados.
É visível apenas dentro da classe, mas sua vida útil é o programa inteiro.
O membro de dados estáticos é definido pela palavra-chave "static‟
Sintaxe:
Nome da classe do tipo de dados::Nome do static_variable;
Ex: int item::count;
#include<conio.h>
item de classe
{
contagem estática int;
número int;
público:
void getdata(int a) {
número=a; contagem++;
}
void getcount()
{
cout<<"count é"<<count;
}
};
int item::count;//decleration
int main()
{
item a,b,c;
a.getcount();
b.getcount();
c.getcount();
a.getdata(100);
b.getdata(200);
c.getdata(300);
cout<<"Após a leitura dos dados";
a.getcount();
b.getcount();
c.getcount();
retorno 0;
}
Saída:
contagem é 0
contagem é 0
contagem é 0
Após a leitura dos dados
contagem é 3
contagem é 3
contagem é 3
Funções de membro estático
Como variável de membro estático, também podemos ter funções de membro estático. Uma função de
membro declarada estática tem as seguintes propriedades:
Uma função estática pode ter acesso apenas a outros membros estáticos (funções ou variáveis)
declarados na mesma classe.
Uma função de membro estático deve ser chamada usando o nome da classe (em vez de seus objetos) da
seguinte maneira: class-name :: function-name;
Teste de classe
{
código int;
contagem estática int;
público:
void setcode()
{
código=++contagem;
}
void showcode()
{
cout<<"número do objeto"<<código;
}
Estática void showcount()
{
cout<<"contar"<<contar;
}
};
teste int::contagem;
int main()
{
teste t1,t2;
t1.setcode();
t2.setcode();
teste::showcount();
teste t3;
t3.setcode();
teste::showcount();
t1.showcode();
t2.showcode();
t3.showcode();
retorno 0;
}
Saída:
contagem 2
contagem 3
objeto número 1
objeto número 2
objeto número 3
Matrizes de objetos: Matrizes de variáveis do tipo "classe" é conhecida como "matriz de objetos". Uma matriz
de objetos é armazenada dentro da memória da mesma forma que em uma matriz comum.
Sintaxe:
classe class_name
{
privado:
data_type membros;
público:
data_type membros; funções de membro;
};
Matriz de objetos:
Class_name object_name[tamanho];
Onde tamanho é o tamanho da matriz
Ex:
Myclass obj[10];
Escrever um programa para inicializar matriz de objetos e imprimi-los
#include<iostream>
classe MyClass
{
Int A;
público:
conjunto void (int x)
{
a=x;
}
int get()
{
retorno a;
}
};
int main()
{
MyClass obj[5];
for(int i=0;i<5;i++)
obj[i].set(i);
for(int i=0;i<5;i++)
cout<<"obj["<<i<<"].get():"<<obj[i].get()<<endl;
}
Saída:
obj[0].get():0
obj[1].get():1
obj[2].get():2
obj[3].get():3
obj[4].get():4
Objetos como argumentos de função: Os objetos podem ser usados como argumentos para
Isso pode ser feito de três maneiras
a. Passe por valor ou chamada por valor
b. Endereço de passagem ou chamada por endereço
c. Passagem por referência ou chamada por referência
a.Pass-by-value – Uma cópia do objeto (objeto real) é enviada para a função e atribuída ao objeto da função
chamada (objeto formal). Cópias reais e formais de objetos são armazenadas em locais de memória diferentes.
Assim, as alterações feitas no objeto formal não são refletidas no objeto real. Escrever um programa para trocar
valores de dois objetos
Escrever um programa para trocar valores de dois objetos
amostra de classe2;
Classe Exemplo1
{
Int A;
público:
void getdata(int x);
exibição do vazio do amigo (sample1 x, sample2 y);
troca de vazio amigo (sample1 x, sample2 y);
};
void sample1::getdata(int x)
{
a=x;
}
Exemplo de classe2
{
Int B;
público:
troca de vazio amigo (sample1 x, sample2 y);

};
{
b=x;
}
exibição void (sample1 x, sample2 y)
{
cout<<"Dados no objeto 1 são"<<endl;
Cout<<"a="<<x.a<<endl;
cout<<"b="<<y.b<<endl;
}
troca nula (sample1 x, sample2 y)
{
Int t;
t=x.a;
x.a=y.b;
y.b=t;
}
int main()
{
amostra1 obj1;
amostra2 obj2;
obj1.getdata(5);
obj2.getdata(15);
cout<<"Antes da troca de dados entre dois objetos\n
"; Exibição (OBJ1,OBJ2);
permuta(obj1,obj2);
cout<<"após Troca de dados entre dois objetos\n ";
Exibição (OBJ1,OBJ2);
}
Antes da troca de dados entre dois objetos
Os dados no objeto 1 são a=5
Os dados no objeto 2 são b=15
após Troca de dados entre dois objetos
b. Endereço de passagem: O endereço do objeto é enviado como argumento para a função.
Aqui ampersand(&) é usado como operador de endereço e seta (->) é usado como operador de referência. Se
alguma alteração feita em argumentos formais, então há uma alteração nos argumentos reais: escrever um
programa para trocar valores de dois objetos:
amostra de classe2;
Classe Exemplo1
{
Int A;
público:
troca de vazio amigo (sample1 *x,sample2 *y);
};
{
a=x;
}
Exemplo de classe2
{
Int B;
público:
troca de vazio amigo (sample1 *x,sample2 *y);
};
{
b=x;
}
{
}
troca nula (sample1 *x, sample2 *y)
{
Int t;
t=x->a;
x->a=y->b;
y->b=t;
}
int main()
{
amostra1 obj1;
amostra2 obj2;
obj1.getdata(5);
obj2.getdata(15);
cout<<"Antes da troca de dados entre dois objetos\n ";
swap(&obj1,&obj2);
}
Os dados no objeto 2 são b=5 c.Pass-by-reference:Uma referência de objeto é enviada como argumento para a
função.
A referência a uma variável fornece um nome alternativo para uma variável definida anteriormente. Se alguma
alteração for feita na variável de referência, então haverá uma alteração na variável original.
Uma variável de referência pode ser declarada da seguinte forma:
Tipo de dados & variável de referência =variável;
int x=5;
int &y=x;
Ex:
Escreva um programa para encontrar a soma de n números naturais usando a variável de referência
int main()
{
int i=0;
int &j=i;
int s=0;
Int n;
cout<<"Digite n:";
cin>>n;
enquanto(j<=n)
{
s=s+i;
i++;
}
cout<<"sum="<<s<<endl;
}
Saída:
Digite n:10
soma=55
Escrever um programa para trocar valores de dois objetos
amostra de classe2;
Classe Exemplo1
{
Int A;
público:
troca de vazio amigo (sample1 &x, sample2 &y);
};
{
a=x;
}
Exemplo de classe2
{
Int B;
público:
troca de vazio amigo (sample1 &x, sample2 &y);
};
{
b=x;
}
{
}
troca de vazios (sample1 &x, sample2 &y)
{
Int t;
t=x.a;
x.a=y.b;
y.b=t;
}
int main()
{
amostra1 obj1;
amostra2 obj2;
obj1.getdata(5);
obj2.getdata(15);
cout<<"Antes da troca de dados entre dois objetos\n ";
permuta(obj1,obj2);
}
Saída:
FUNÇÕES DE AMIGO:Os membros privados não podem ser acessados de fora da classe. Uma função
não membro não pode ter acesso aos dados privados de uma classe. Em C++, uma função não membro pode
acessar private tornando a função amigável para uma classe.
Definição:
Uma função de amigo é uma função que é declarada dentro de uma classe e é definida fora da classe.
Ele não requer nenhum operador de resolução de escopo para definir . Ele pode acessar membros privados de
uma classe. É declarado usando a palavra-chave " amigo"
Ex:
Amostra de classe
{ int x,y; público: amostra(int a,int b);
amigo int sum(amostras s);
};
amostra::sample(int a, int b)
{ x=a;y=b;
}
int sum(amostras s)
{ int sum;
soma=s.x+s.y;
retorno 0;
}
void principal()
{
Amostra obj(2,3);
int res=soma(obj);
cout<< "sum="<<res<<endl;
}
Uma função de amigo possui certas características especiais:
Não está no âmbito da classe a que foi declarado amigo.
Como ele não está no escopo da classe, ele não pode ser chamado usando o objeto dessa classe. Ele pode ser invocado como
uma função normal sem a ajuda de qualquer objeto.
Ao contrário das funções de membro, ele não pode acessar os nomes de membro diretamente e precisa usar um nome de objeto
e um operador de associação de ponto com cada nome de membro.
Pode ser declarado na parte pública ou privada de uma classe sem afetar seu significado.
Normalmente, tem os objetos como argumentos.
Exemplo de classe #include<iostream.h>
{
Int A;
Int B;
público:
void setvalue()
{
a=25;
b=40;
}
média de flutuação amiga (amostra s);
};
média flutuante (amostra s)
{
flutuador de retorno (s.a+s.b)/2.0;
}
int main()
{
amostra X;
X.valor_conjunto();
cout<<"Valor médio="<<média(X);
retorno 0;
}
Escreva um programa para encontrar o máximo de dois números usando a função Friend para duas
classes diferentes #include<IOstream>
amostra de classe2;
Classe Exemplo1
{
Int X;
público:
amostra1(int a);
amigo void max (sample1 s1, sample2 s2)
};
amostra1::amostra1(int a)
{
x=a;
}
Exemplo de classe2
{
Int Y;
público:
amostra2(int b);
amigo void max (sample1 s1, sample2 s2)
};
Amostra2::amostra2(int b)
{
y=b;
}
void max (amostra1 s1, amostra2 s2)
{
Se(s1.x>s2.y)
cout<<"Membro de dados em Object da classe sample1 é maior "<<endl;
mais
cout<<"Membro de dados em Object da classe sample2 é maior "<<endl;
}
void principal()
{
amostra1 obj1(3);
amostra2 obj2(5);
máx(obj1,obj2);
}
Escrever um programa para adicionar números complexos usando a função de amigo
#include<iostream>
complexo de classes
{
flutuar real, img;
público:
complexo();
complexo (float x, float y)
complexo amigo add_complex(complexo c1, complexo c2);
};
complexo::complexo()
{
real=img=0;
}
complexo: : complexo (float x, float y)
{
real=x;img=y;
}
complexo add_complex(complexo c1, complexo c2)
{
complexo t;
t.real=c1.real+c2.real;
t.img=c1.img+c2.img;
retorno t;
}
complexo vazio: :d isplay ()
{
se(img<0)
{img=-img;
cout<<real<<"-i"<<img<<endl
} else { cout<<real<<"+i"<<img<<endl
}
}
int main()
{
complexo obj1(2,3);
complexo obj2(-4,-6);
complexo obj3=add_compex(obj1,obj2);
obj3.display();
retorno 0;
}
Classe de amigos:Uma classe também pode ser declarada amiga de alguma outra classe. Quando criamos
uma classe de amigos, todas as funções de membro da classe de amigos também se tornam amigas da outra
classe. Isso requer a condição de que o amigo que se torna classe deve ser primeiro declarado ou definido
(declaração encaminhada).
#include <iostream.h>
classe sample_1
{
classe de amigos sample_2;//declarando classe de amigos
Int A,B;
público:
void getdata_1()
{
cout<<"Insira valores A & B na classe sample_1";
cin>>a>>b;
}
void display_1()
{
cout<<"A="<<a<<endl;
cout<<"B="<<b<<endl;
}
};
classe sample_2
{
int c,d,soma;
sample_1 obj1;
público:
void getdata_2()
{
obj1.getdata_1();
cout<<"Insira os valores C & D na classe sample_2"; cin>>c>>d;
}
void sum_2()
{
soma=obj1.a+obj1.b+c+d;
}
void display_2()
{
cout<<"A="<<obj1.a<<endl;
cout<<"B="<<obj1.b<<endl;
cout<<"C="<<c<<endl;
cout<<"D="<<d<<endl;
cout<<"SUM="<<soma<<endl;
}
};
int main()
{
sample_1 s1;
s1.getdata_1();
s1.display_1();
sample_2 s2;
s2.getdata_2();
s2.sum_2();
s2.display_2();
}
Insira valores A & B na classe sample_1:1 2

A=1
B=2
Insira os valores A & B na classe sample_1:1 2 3 4
Insira os valores C & D na classe sample_2:A=1
B=2
C=3
D=4
SUM=10
UNIDADE -3
Construtores, Destruidores, Herança:

Introdução a construtores, construtores padrão, construtores parametrizados, construtores de cópia vários
construtores em uma classe, destruidores.
Herança:Introdução à herança, Definição de classes derivadas, Herança única, Herança múltipla, Herança
multinível, Herança hierárquica, Herança híbrida.
D
Introdução aos construtores: C++ fornece uma função de membro especial chamada
construtor que permite que um objeto inicialize a si mesmo quando ele é criado.
Definição:- Um construtor é uma função de membro especial cuja tarefa é inicializar os objetos de sua
classe. É especial porque seu nome é o mesmo nome que o nome da classe. O construtor é chamado
sempre que um objeto de sua classe associada é criado. Ele é chamado de construtor porque constrói os
valores dos membros de dados da classe.
Um construtor é declarado e definido da seguinte forma:
inteiro obj1; => não apenas cria o objeto OBJ1, mas também inicializa seus membros de dados m e n para zero.
Não há necessidade de escrever nenhuma instrução para invocar a função do construtor.
CARACTERÍSTICAS DO CONSTRUTOR
> Eles devem ser declarados na seção pública.
Eles são chamados automaticamente quando os objetos são criados.
> Eles não têm tipo de retorno, nem mesmo vazio.
Eles não podem ser herdados, embora uma classe derivada possa chamar o
construtor de classe base.
> Como outras funções do c++, elas podem ter argumentos padrão.
> Os construtores não podem ser virtuais.
>
Eles fazem "chamadas implícitas" para os operadores novos e excluem quando a alocação de memória é
necessária.
Os construtores são de 3 tipos:
1. Default Construtor
2. Construtor parametrizado
3. Copy Construtor
1 . Construtor padrão: Um construtor que não aceita parâmetros é chamado de construtor padrão.
#include<conio.h> item de classe
{
Int M,N;
público:
item()
{
m=10;
n=20;
}
void put();
};
item nulo::p ut() {
Cout<<M<<N;
}
void principal()
{
item t;
t.put();
getch();
}
2 . Construtores parametrizados:-Os construtores que tomam parâmetros são chamados de
construtores parametrizados.
item de classe
{
Int M,N;
público:
item(int x, int y)
{
m=x;
n=y;
}
};
Quando um construtor foi parametrizado, a instrução de declaração de objeto, como o item t;
pode não funcionar. Devemos passar os valores iniciais como argumentos para a função do construtor
quando um objeto é declarado. Isso pode ser feito de 2 formas: item t=item(10,20); chamada explícita
item t(10,20); chamada implícita

Eg:
#include<conio.h>
item de classe
{
Int M,N;
público:
item (int x, int y)
{
m=x;
n=y;
}
void put();
};
item nulo: :p ut()
{
Cout<<M<<N;
}
void principal()
{
item T1(10,20);
item t2=item(20,30);
t1.put();
t2.put();
getch();
}
3 . Copy Construtor: Um construtor copy é usado para declarar e inicializar um objeto de
outro objeto.
Eg:
item t2(t1);
ou
item t2=t1;
1. O processo de inicialização por meio de um construtor de cópia é conhecido como inicialização de

cópia.
2. t2=t1 não invocará o construtor copy. t1 e t2 são objetos, atribui os valores de t1 a t2.
3. Um construtor copy usa uma referência a um objeto da mesma classe que ele mesmo como
um argumento. #include<iostream.h>
Amostra de classe
{
Int n;
público:
amostra()
{
n=0;
}
Amostra(int a)
{
n=a;
}
amostra(amostra &x)
{
n=x.n;
}
exibição vazia()
{
Cout<<n;
}
};
void principal()
{
amostra A(100);
amostra B(A);
amostra C=A;
amostra D;
D=A;
A.display();
B.display();
C.display();
D.display();
}
Saída: 100 100 100 100
Vários construtores em uma classe: Vários construtores podem ser declarados em uma classe. Pode
haver qualquer número de construtores em uma classe.
complexo de classes
{
flutuar real, img;
público:
complex()//default construtor
{
real=img=0;
}
Complex(float R)//Single Parameter Construtor parametrizado

{
real=img=r;
}
complex(float r,float i) //two parameter parameterized construtor

{
real=r;img=i;
}
complex(complex&c)//copy construtor
{
real=c.real;
img=c.img;
}
soma complexa (complexo c ) {
complexo t;
t.real=real+c.real;
t.img=img+c.img;
retorno t;
}
void show()
{
Se(img>0)
cout<<real<<"+i"<<img<<endl;
mais
{
img=-img;
cout<<real<<"-i"<<img<<endl;
}
};
void principal()
{
complexo c1(1,2);
complexo c2(2,2);
Compex C3;
c3=c1.soma(c3);
c3.show();
DESTRUIDORES:Um destruidor, é usado para destruir os objetos que foram criados por um construtor.
Como um construtor, o destruidor é uma função de membro cujo nome é o mesmo que o nome da
classe, mas é precedido por um til.
Ex: ~item() { }
1. Um destruidor nunca aceita nenhum argumento nem retorna qualquer valor.
2. Ele será invocado implicitamente pelo compilador ao sair do programa para limpar o armazenamento
que não está mais acessível.
3. É uma boa prática declarar destruidores em um programa, uma vez que ele libera espaço de memória
para uso futuro.
#include<iostream>
Marcas de classe
{
público:
int matemática;
int ciência;
construtor
Marcas() {
cout << "Inside Constructor"<<endl;
cout << "Objeto C++ criado"<<endl;
}
Destruidor
~Marcas() {
cout << "Inside Destructor"<<endl;
cout << "Objeto C++ destruído"<<endl;
}
};
int principal( )
{
Marcas m1;
Marcas m2;
retorno 0;
}
Saída:
Inside Construtor
Objeto C++ criado
Inside Construtor
Objeto C++ criado
Por dentro do Destruidor
Objeto C++ destruído
Por dentro do Destruidor
Objeto C++ destruído
HERANÇA: . O mecanismo de derivar uma nova classe de uma antiga é chamado de herança ou
derivação. A classe antiga é chamada de classe base e a nova é chamada de classe derivada ou subclasse. A
classe derivada herda alguns ou todos os traços da classe base.
Uma classe também pode herdar propriedades de mais de uma classe ou de mais de um nível. A
reutilização é uma característica importante da OOP
Uma classe derivada pode ser definida especificando sua relação com a classe base, além de seus próprios
detalhes.
class derived-class-name : visibility-mode base-class-name {
Os dois pontos indicam que o nome da classe derivada é derivado do nome da classe base. O modo de
visibilidade é opcional e, se presente, pode ser privado ou protegido ou público. O padrão é privado. O modo
de visibilidade especifica se os recursos da classe base são derivados de forma privada ou derivada
publicamente.
derivação privada
classe ABC : privado XYZ {
membros da ABC;
};
classe ABC:XYZ pública
{
membros da ABC;
};
derivação pública
classe ABC:protegido XYZ { // derivação protegida membros do ABC;

};
classe ABC:XYZ privado por padrão
{
membros da ABC;
};
Quando uma classe base é herdada privadamente por uma classe derivada, os membros públicos da
classe base só podem ser acessados pelas funções de membro da classe derivada.membes privados da classe
base são inacessíveis aos objetos da classe derivada
Quando uma classe base é protegida herdada por uma classe derivada, os membros públicos da classe
base só podem ser acessados pelas funções de membro da classe derivada.membes privados da classe base são
inacessíveis aos objetos da classe derivada. Se os membros privados da classe base devem ser herdados para a
classe derivada, declare-os como protegidos
Quando a classe base é herdada publicamente, os membros públicos da classe base são herdados
publicamente, os membros públicos da classe base tornam-se membros públicos da classe derivada e, portanto,
são acessíveis aos objetos da classe derivada. Em ambos os casos, os membros privados não são herdados e,
portanto, os membros privados de uma classe base nunca se tornarão os membros de sua classe derivada
Na herança, alguns dos elementos de dados da classe base e funções de membro são "herdados‟ na
classe derivada. Podemos adicionar nossos próprios dados e funções de membro e, assim, estender a
funcionalidade da classe base. A herança, quando usada para modificar e estender a capacidade das classes
existentes, torna-se uma ferramenta muito poderosa para o desenvolvimento de programas incrementais
Visibilidade dos membros herdados

Visibilidade de elatos derivada
Baur cUu* vitibilidade
Derivação
pública Derivação privada Derivação protegida
Privado —♦ Não herdado Não herdado
Não herdado Protegido
Protegido ♦ Privado Protegido
Público — Público Privado Protegido
Tipos de herança: 1.Herança única 2.Herança multinível 3.Herança mutipilar 4.Herança híbrida 5. Herança
Hierárquica.
1.HERANÇA ÚNICA: uma classe derivada herda de apenas uma classe base. É a forma mais simples de
herança.
A / /Classe base
B //Classe derivada
#include<iostream> usando namespace std; classe A { public: int a,b; void get() { cout<<"Digite quaisquer dois
valores inteiros"<<endl; cin>>a>>b;
} };
classe B:público A {
Int C;
público:
void add()
{ c=a+b;
cout<<a<<"+"<<b<<"="<<c;
}
};
int main()
{
B b;
b.get();
b.add();
}
Saída:
Insira quaisquer dois valores inteiros
12
1+2=3
2.HERANÇA MULTINÍVEL: Nesse tipo de herança, a classe derivada herda de uma classe, que por sua vez
herda de alguma outra classe. A classe Super para um, é subclasse para o outro.
classe A
{
público:
Int A,B;
void get()
{
cout<<"Insira quaisquer dois valores inteiros"<<endl;
cin>>a>>b;
}
};
classe B: público A
{
público:
Int C;
void add()
{
c=a+b;
}
};
classe C: público B
{
público:
void show()
{
cout<<a<<"+"<<b<<"="<<c;
}
};
int main()
{
C c;
c.get();
c.add();
c.show();
}
Saída:
Insira quaisquer dois valores inteiros
12 14
12+14=26
3 . Herança múltipla:Neste tipo de herança, uma única classe derivada pode herdar de duas ou mais de
duas classes base.
Sintaxe:
classe D : visibilidade A, visibilidade B,.... {
classe A
{
público:
Int A;
void getA()
{
cout<<"Insira um valor inteiro"<<endl; Cín>>A;
}
};
classe B
{
público:
Int B;
void getB()
{
cout<<"Insira um valor inteiro"<<endl; Cín>>B;
}
};
classe C: público A, público B

{
público:
Int C;
void add()
{
c=a+b;
cout<<a<<"+"<<b<<"="<<c<<endl;
}
};
int main()
{
C obj;
obj.getA();
obj.getB();
obj.add();
}
Insira um número inteiro
valor 12 Insira um
Valor inteiro 13 12+13=25
4 . Herança híbrida: A herança híbrida é a combinação de duas ou mais heranças, como heranças únicas,
múltiplas, multinível ou hierárquicas.
Aritmética de classe
{
Protegido:
int núm1, núm2;
público:
void getdata()
{
cout<<"Para Adição:";
cout<<"\nDigite o primeiro número: ";
cin>>num1;
cout<<"\nDigite o segundo número: ";
cin>>num2;
}
};
Classe Plus:Aritmética Pública
{
Protegido:
int sum;
público:
void add()
{
soma=núm1+núm2;
}
};
classe menos
{
Protegido:
int n1,n2,diff;
público:
void sub()
{
cout<<"\nPara subtração:";
cout<<"\nDigite o primeiro número: ";
cin>>n1;
cout<<"\nDigite o segundo número: ";
cin>>n2;
diff=n1-n2;
} };
Resultado da classe:Público mais, Público menos
{
público:
exibição vazia()
{
cout<<"\nSoma de "<<num1<<" e "<<num2<<"= "<<soma;

cout<<"\nDiferença de "<<n1<<" e "<<n2<<"= "<<diff;
}
};
int main()
{
resultado z;
z.getdata();
z.add();
z.sub();
z.display();
}
Para adição:
Digite o primeiro número: 1
Digite o segundo número: 2
Para Subtração:
Digite o primeiro número: 3
Digite o segundo número: 4
Soma de 1 e 2= 3
Diferença de 3 e 4= -1
5 . Herança hierárquica:- Herdar é um método de herança onde uma ou mais classes derivadas são
derivadas da classe base comum.
#include<iostream.h> classe A //Classe base {

público:
Int A,B;
void getnumber()
{
cout<<"\n\nDigite o número :\t"; Cín>>A;
}
};
classe B : pública A //Derivada classe 1
{
público:
quadrado vazio()
{
getnumber(); Chamar propriedade de classe base cout<<"\n\n\tSquare do número :\t"<<(a*a);
}
};
classe C :p ublic A //Derivada classe 2
{
público:
cubo vazio()
{
getnumber(); Chamar a propriedade de classe base cout<<"\n\n\tCube do número :::\t"<<(a*a*a);
}
};
int main()
{
B b1; b1 é objeto da classe derivada 1
b1.quadrado(); função de membro de chamada da classe B C c1; c1 é objeto da classe derivada 2
c1.cubo(); chamar função de membro da classe C }
Quadrado do número : 4
Cubo do número ::: 27

UNIDADE -4
Ponteiros, Funções Virtuais e Polimorfismo:Introdução, Gerenciamento de Memória, novo Operador e

Operador de exclusão, Ponteiros para Objetos, este Ponteiro, Ponteiros para
Classes derivadas,Polimorfismo,Polimorfismo em tempo de compilação,Polimorfismo em tempo de
execução, Virtual
Funções,Funções virtuais puras,Classes de base virtual,Destruidores virtuais,Função
Sobrecarga, Sobrecarga do operador, Regras para sobrecarga do operador - operadores binários e unários.
Introdução ao gerenciamento de memória:
ALOCAÇÃO DINÂMICA DE MEMÓRIA & DESALOCAÇÃO (new & delete)

C usa as funções malloc() e calloc() para alocar memória dinamicamente em tempo de execução. Ele usa a
função free() para desalocar memória alocada dinamicamente.
C++ suporta essas funções, ele define dois operadores unários novo e excluir que executam a tarefa de alocar e
Deslocando a memória de uma maneira melhor e mais fácil.
Um objeto pode ser criado usando novo e destruído usando excluir.
Um objeto de dados criado dentro de um bloco com new, permanecerá na existência até que seja
explicitamente
destruído usando delete.
novo operador:-
O operador NEW pode ser usado para criar objetos de qualquer tipo. Assim, o novo operador
aloca memória suficiente para armazenar dados de objetos e retorna o endereço da memória alocada.
Sintaxe:
pointer-variable = novo tipo de dados;
Ex: int *p = novo int;
>
Para criar espaço de memória para matrizes: pointer-variable = new data-type[size];
Ex: int *p = novo int[10];
DElete Operador:
Se a variável ou objeto não é mais necessário ou necessário é destruído pelo operador "delete", lá
por alguma quantidade de memória é liberada para fins futuros. Synatx:
excluir variável de ponteiro;
Ex: excluir p;
>
Se quisermos liberar um alocado dinamicamente
matriz: excluir [tamanho] ponteiro-variável;
Programa: escrever um programa para encontrar a soma da lista de inteiros #include<iostream> usando
namespace std; int main()
{
int n,*p;
cout<<"Digite o tamanho da matriz:";
cin>>n;
p=novo int[n];
cout<<"Entrar lista de inteiros"<<endl;
for(int i=0;i<n;i++)
cin>>p[i];
lógica para somação
int s=0;
for( int i=0;i<n;i++)
s=s+p[i];
cout<<"Soma dos elementos da matriz é\n";
cout<<s;
excluir [ ]p;
retorno 0;
}
Digite o tamanho da matriz:5
Insira a lista de números inteiros
1 2345
A soma dos elementos da matriz é
15
Operador de desreferenciação de membros:-

membro
2. Ponteiro para operador membro ->*
Ponteiro para um declarador de membro ::*
Esse operador é usado para declarar um ponteiro para o membro da classe #include<iostream.h>
Amostra de classe
{público:
Int X;
};
int main()
{ amostras; objeto
s.*p=10; correto
Cout<<S.*P;
}
Saída: 10
2 . Ponteiro para operador membro ->*
Amostra de classe
{
público:
Int X; void
display() {
}
};
int main()
{
amostras; objeto
amostra *ptr;
int amostra::*f=&amostra::x;
s.x=10;
ptr=&s;
COUT<<PTR->*F;
ptr->display();
}
3 . Ponteiro para operador membro .*

Amostra de classe
{
público:
Int X;
};
int main()
{
amostras; objeto
s.*p=10; correto
Cout<<S.*P;
}
Ponteiros para objetos:Ponteiros para objetos são úteis para criar objetos em tempo de execução. Para
acessar membros operador de seta ( ) e operador de referência ou indireção (*) são usados.
Declaração de ponteiro.
className*ptr
ex:
item *obj;
Aqui obj é um ponteiro para objeto do item de tipo.
item de classe
{
código int;
preço flutuante;
público:
void getdata(int a,float b)
{
código=a;
preço=b;
}
void show()
{
cout<<"código:"<<código<<"\n"<<"Preço:"<<preço<<endl;
}
};
Declaração de objeto e ponteiro para item de classe: item obj;

item *ptr=&obj;
O membro pode ser acessado da seguinte forma.
a) Acesso aos membros utilizando o operador de ponto obj.getdata(101,77.7); obj.show();
b) usando o ponteiro
PTR->GetData(101.77,7);
ptr->show();
c)Usando operador de referência e operador de ponto (*ptr).getdata(101,77.7);
(*ptr).show();
Criando matriz de objetos usando ponteiro: item *ptr=new item[10];
A declaração acima cria espaço de memória para uma matriz de 10 objetos do item de tipo.
#include<iostream.h> item de classe

{
código int;
preço flutuante;
público:
void getdata(int a,float b) {
código=a; preço=b;
}
void show()
{
cout<<código<<"\t"<<preço<<endl;
}
};
int main()
{
Int n;
Int CD;
flutuador pri;
cout<<"Digite o número de objetos a serem criados:";
cin>>n;
item *ptr=novo item[n];
item *p;
p=ptr;
for(int i=0;i<n;i++) {
cout<<"Inserir dados para o objeto"<<i+1;
cout<<"\nDigite o código:";cin>>cd;
cout<<"Digite o preço:";cin>>pri;
P->GetData(CD,PRI);
p++;
}
p=ptr;
cout<<"Dados em vários objetos são "<<endl;
cout<<"Sno\tCode\tPrice\n";
for(i=0;i<n;i++)
{
cout<<i+1<<"\t";
ptr->show();
PTR++;
}
retorno 0;
}
Ponteiros para classes derivadas: Os ponteiros podem ser declarados para a classe derivada. ele pode
ser usado para acessar membros da classe base e da classe derivada. Um ponteiro de classe base também pode
ser usado para apontar para o objeto da classe derivada, mas pode acessar somente os membros que são
herdados da classe base.
base de classe
{
público:
Int A;
void get_a(int x)
{
a=x;
}
void display_a()
{
cout<<"Na base"<<"\n"<<"a="<<a<<endl;
}
};
classe derivada:base pública
{
Int B;
público:
void get_ab(int x,int y)
{
a=x;
b=y;
}
void display_ab()
{
cout<<"Em Derivado "<<"\n"<<"a="<<a<<"\nb="<<b<<endl;
}
};
int main()
{
base b;
base *bptr;
bptr=&b;//aponta para o objeto da classe base
BPTR->get_a(100);
BPTR->display_a();
derivado d;
derivado *dptr;
dptr=&d;//aponta para o objeto da classe derivada
DPTR->get_a(400);
DPTR->display_a();
DPTR->get_ab(300.200);
DPTR->display_ab();
bptr=&d;//aponta para o objeto da classe derivada bptr->get_a(400);

BPTR->display_a();
retorno 0;
}
Saída:
Na base
a=100
Na base
a=400
Em Derivado
a=300
b=200
Na base
a=400
POLIMORFISMO DE TEMPO DE EXECUÇÃO USANDO FUNÇÕES VIRTUAIS

Vinculação dinâmica de & estático
Polimorfismo significa "um nome‟ -"múltiplas formas.
As funções de membro sobrecarregadas são "selecionadas‟ para invocar por argumentos correspondentes,
tanto de tipo quanto de número. Essas informações são conhecidas pelo compilador no momento da
compilação e o compilador é capaz de selecionar a função apropriada para uma chamada específica no próprio
momento da compilação. Isso é chamado de vinculação antecipada ou vinculação estática ou vinculação
estática. Também conhecido como polimorfismo de tempo de compilação. A vinculação antecipada
significa que um objeto está vinculado à sua chamada de função no momento da compilação.
Seria bom se a função de membro apropriada pudesse ser selecionada enquanto o programa está em
execução. Isso é conhecido como polimorfismo de tempo de execução. O C++ oferece suporte a um
mecanismo conhecido como função virtual para obter polimorfismo em tempo de execução.
No tempo de execução, quando se sabe quais objetos de classe estão sendo considerados, a versão
apropriada da função é invocada. Uma vez que a função é ligada a uma classe específica muito mais tarde após
a compilação, este processo é denominado como ligação tardia. Também é conhecida como vinculação
dinâmica porque a seleção da função apropriada é feita dinamicamente em tempo de execução.
Função Operador Virtual

Sobrecarga Sobrecarga Funções
FUNÇÕES VIRTUAIS
Polimorfismo refere-se à propriedade pela qual objetos pertencentes a classes diferentes são capazes de
responder à mesma mensagem, mas formas diferentes. Um requisito essencial do polimorfismo é, portanto, a
capacidade de se referir a objetos sem qualquer consideração por suas classes.
Quando usamos o mesmo nome de função nas classes base e derivada, a função na classe bas é
declarada como virtual usando a palavra-chave virtual que precede sua declaração normal.
Quando uma função é tornada virtual, o C++ determina qual função usar em tempo de execução com base no
tipo de objeto apontado pelo ponteiro base, em vez do tipo do ponteiro. Assim, fazendo com que o ponteiro
base aponte para diferentes objetos, podemos executar diferentes versões da função virtual.
Base de classe
{
público:
exibição vazia()
{
cout<<"Base de Exibição";
}
Vazio Virtual Show()
{
cout<<"Mostrar Base";
}
};
classe Derivada : Base pública
{
público:
exibição vazia()
{
cout<<"Display Derivado";
}
void show()
{
cout<<"show derivado";
}
};
void principal()
{
Base b;
Derivado d;
Base *ptr;
cout<<"ptr aponta para Base";
ptr=&b;
ptr->display(); Base de chamadas
ptr->show(); / /chama Base
cout<<"ptr aponta para derivado";
ptr=&d;
ptr->display(); Base de chamadas
ptr->show(); classe Derivada
}
Saída:
ptr aponta para Base

Base de exibição
Mostrar Base
ptr aponta para Derivado
Base de exibição
Mostrar derivado
Quando ptr é feito para apontar para o objeto d, a instrução ptr->display(); chama apenas a função
associado à Base, ou seja, Base::d isplay()
onde como a declaração
ptr->show();
chama a versão derivada de show(). Isso ocorre porque a função display() não foi tornada virtual na classe
Base.
Regras para funções virtuais:
Quando funções virtuais são criadas para implementar a vinculação tardia, observe algumas regras
básicas que satisfazem os requisitos do compilador.
1. As funções virtuais devem ser membros de alguma classe.

2. Eles não podem ser membros estáticos.
3. Eles são acessados usando ponteiros de objeto.
4. Uma função virtual pode ser amiga de outra turma.
5. Uma função virtual em uma classe base deve ser definida, mesmo que não possa ser usada.
6. Os protótipos da versão de classe base de uma função virtual e todas as versões de classe derivadas
devem ser idênticas. O C++ as considera como funções sobrecarregadas, e o mecanismo de função
virtual é ignorado.
7. Não podemos ter construtores virtuais, mas podemos ter destruidores virtuais.
8. Enquanto um ponteiro base aponta para qualquer tipo do objeto derivado, o inverso não é verdadeiro.
ou seja, não podemos usar um ponteiro para uma classe derivada para acessar um objeto do tipo de
classe base.
9. Quando um ponteiro base aponta para uma classe derivada, incrementá-lo ou decrementá-lo não fará
com que ele aponte para o próximo objeto da classe derivada. Ele é incrementado ou diminuído apenas
em relação ao seu tipo de base. Portanto, não devemos usar esse método para mover o ponteiro para o
próximo objeto.
10. Se uma função virtual for definida na classe base, ela não precisará ser necessariamente redefinida na
classe derivada. Nesses casos, as chamadas invocarão a função base.
SOBRECARGA
SOBRECARGA DO OPERADOR
O C++ tem a capacidade de fornecer aos operadores um significado especial para um tipo de dados. O
mecanismo de dar tais significados especiais a um operador é conhecido como sobrecarga do operador.
Podemos sobrecarregar todos os operadores, exceto os seguintes:
Operador de acesso de membro de classe ("." E "
.*") Operador de resolução de escopo ": :"
Operador de tamanho (sizeof)
Operador condicional
Para definir uma tarefa adicional a um operador, especifique o que ela significa em relação à classe à
qual o operador é aplicado. Isso é feito com a ajuda de uma função especial, chamada função do
operador. O processo de sobrecarga envolve as seguintes etapas:
1. Crie uma classe que defina o tipo de dados a ser usado na operação de sobrecarga.
2. Declare o operador de função de operador op() na parte pública da classe. Pode ser uma função de
membro ou uma função de amigo.
3. Aqui op é o operador a ser sobrecarregado.
4. Defina a função do operador para implementar as operações necessárias.
Ex:
complexo complexo::operator+(complexo c)
{
complexo t;
t.real=real+c.real;
t.img=img+c.img;
retorno t;
}
Conceito de sobrecarga do operador
Um dos recursos exclusivos do C++ é a sobrecarga do operador. Aplicar sobrecarga aos operadores significa,
mesmo operador em responder de maneira diferente. Por exemplo, o operador + pode ser usado como operador
concatenado, bem como operador adicional.
Isso é 2+3 significa 5 (adição), onde como

"2"+"3" significa 23 (concatenação).
Executar muitas ações com um único operador é sobrecarga do operador. Podemos atribuir uma função
definida pelo usuário a um operador. Podemos mudar a função de um operador, mas não é recomendado alterar
as funções reais do operador. Não podemos criar novos operadores usando esse carregamento de operador.
O conceito de sobrecarga do operador pode ser aplicado nas seguintes duas grandes áreas (Benefícios):
1. Extensão do uso dos operadores
2. Conversões de dados
Regras a serem seguidas para a sobrecarga do operador:-
1 . Apenas os operadores existentes podem ser sobrecarregados.
2 . Os operadores sobrecarregados devem ter pelo menos um operando que seja de operadores
definidos pelo usuário
3 . Não podemos mudar o significado básico de um operador.
4 . Operador sobrecarregado deve seguir características mínimas do operador original
5 . Ao usar a sobrecarga do operador binário através da função de membro, o operando da mão
esquerda deve ser um objeto de classe relevante
O número de argumentos na lista de argumentos do operador sobrecarregado depende
1. A função de operador deve ser a função de membro ou a função de amigo.

2. Se a função operador é uma função amiga, então ela terá um argumento para operador unário
& dois argumentos para operador binário
3. Se a função operador for uma função membro, ela terá o argumento Zero para operador unário e
um argumento para operador binário
Sobrecarga unária do operador

Um operador unário significa um operador que trabalha em um único operando. Por exemplo, ++ é um
operador unário, ele usa um operando único (c++). Assim, ao sobrecarregar um operador unário, ele não usa
argumento (porque o próprio objeto é considerado como argumento).
Sintaxe para operador Unary (dentro de uma classe)
operador do tipo return: operatorSymbol( )

{
corpo da função
}
Ex:
operador void-()
{
real=-real;
img=-img;
}
Sintaxe para operador Unary (Fora de uma classe)
return-type classname::operator operatorSymbol( )
{
corpo da função
}
Exemplo 1:-
void operador++()
{
contador++;
}
Exemplo 2:-
complexo void::operator-()
{
real=-real;
img=-img;
}
O programa simples a seguir explica o conceito de sobrecarga unária.

#include < iostream.h >
#include < conio.h >
Operador do Programa
Sobrecarregando o fato de classe
{
Int A;
público:
fato ()
{
a=0;
} fato (int i) {
a=i;
}
operador de fato! ()
{
int f=1,i;
fato t;
para (i=1;i<=a;i++)
{
f=f*i;
}
t.a=f;
retorno t;
}
exibição vazia()
{
cout<<"O fatorial" << a;
}
};
void principal()
{
Int X;
cout<<"digite um número";
cin>>x;
fato s(x),p;
p=!s;
p.display();
}
Saída para o programa acima:

Digite um número 5
O fatorial de um dado número 120
Explicação:
Tomamos "!‟ como operador para sobrecarregar. Aqui nome de classe é fato. Construtor sem parâmetros para
tomar inicialmente o valor de "x‟ como 0. Construtor com parâmetro para assumir o valor de "x ‟ . Criamos
dois objetos um para fazer o fatorial e outro para retornar o fatorial. Aqui, o número de parâmetros para uma
função sobrecarregada é 0. Fatorial é operador unário porque opera em um item de dados. sobrecarga do
operador localizar o fatorial do objeto. A função de exibição para imprimir o resultado.
Sobrecarregando o operador unário -
Exemplo 1:-
Escrever um programa para sobrecarregar o operador unário –
#include<iostream>
complexo de classes
{
flutuar real, img;
público:
complexo();
complexo (flutuador x, flutuador y);
exibição de vazios();
operador void-();
};
complexo::complexo()
{
real=0;img=0;
}
complexo::complexo (float x, float y)
{
real=x;
img=y;
}
complexo vazio: :d isplay()
{
int imag=img;
se(img<0)
{
imag=-img;
cout<<real<<" -i"<<imag<<endl;
}
mais
cout<<real<<" +i"<<img<<endl;
}
complexo void::operator-()
{
real=-real;
img=-img;
}
int main()
{
complexo c(1,-2);
c.display();
cout<<"Após Unary - operação\n";
-c;
c.display();
}
Exemplo 2:-
espaço de aula
{
Int x,y,z;
público:
void getdata(int a,int b,int c);
operador void-();
};
espaço vazio :: getdata(int a,int b,int c)
{
x=a;
y=b;
z=c;
}
espaço vazio :: display()
{
cout<<"y="<<y<<endl;
cout<<"z="<<z<<endl;
}
espaço vazio :: operador-()
{
x=-x;
y=-y;
z=-z;
}
int main()
{
espaço s;
s.getdata(10,-20,30);
s.display();
-s;
cout<<"após a negação\n";
s.display();
}
Saída:
x=10
y=-20
z=30
após a negação
x=-10
y=20
z=-30
É possível sobrecarregar um operador unary minus usando uma função friend da seguinte maneira:
amigo operador vazio-(espaço &s);
Exemplo 3:-
Unary menos operador usando uma função de amigo
espaço de aula
{
Int x,y,z;
público:
void getdata(int a,int b,int c);
amigo operador vazio-(espaço &);
};
espaço vazio :: getdata(int a,int b,int c)
{
x=a;
y=b;
z=c;
}
espaço vazio :: display()

{
Cout<<X<<" "<<Y<<" "<<z<<endl;
}
void operator-(espaço &s)
{
s.x=-s.x;
s.y=-s.a;
s.z=-s.z;
}
int main()
{
espaço S;
S.getdata(10,-20,30);
S.display();
-S;
cout<<"após a negação\n";
S.display();
}
Saída:
10 -20 30
após a negação
-10 20-30
Sobrecarga do operador binário

Um operador binário significa, um operador que trabalha em dois operandos. Por exemplo, + é um operador
binário, ele leva um operando único (c + d). Assim, ao sobrecarregar um operador binário, ele usa um
argumento (um é o próprio objeto e outro é o argumento passado).
Sintaxe para operador binário (dentro de uma classe) operador do tipo de retorno
operatorsymbol(argument) {
corpo da função
}
Sintaxe para definição de operador binário (Fora de uma classe ) return-type classname::operator
operatorsymbol(argument) {
corpo da função
}
Exemplo de operador complexo+(complexo s)

{
complexo t;
t.real=real+s.real;
t.img=img+s.img;
retorno t;
}
O programa a seguir explica a sobrecarga do operador binário:
soma das aulas
{
Int A;
público:
soma()
{
a=0;
}
soma(int i)
{
a=i;
}
operador de soma+(soma p1)
{
soma t;
t.a=a+p1.a;
retorno t;
}
void principal ()
{
cout<<"Digite dois números:"
Int A,B;
cin>>a>>b;
soma x(a),y(b),z;
z.display();
z=x+y;
cout<<"após a aplicação do operador \n";
z.display();
getch();
}
Saída para o programa acima:
Digite dois números 5 6
Após a aplicação do operador
A soma de dois números 11
Explicação: O nome da classe é "sum‟ . Criamos três objetos, dois para fazer a soma e outro para devolver a
soma. ‟ +‟ é um operador binário opera em membros de dois objetos e retorna o resultado que é membro de um
objeto.aqui número de parâmetros são 1. A soma é exibida na função de exibição.
Escrever um programa para sobrecarregar operadores aritméticos em números complexos usando a

função de membro
complexo de classes
{
flutuar real, img;
público:
complex(){ }
{
real=x;
img=y;
}
operador complexo+(complexo c) exibição vazia();
};
complexo complexo::operator+(complexo c)
{
temperatura complexa;
temp.real=real+c.real;
temp.img=img+c.img;
temperatura de retorno;
}
{
int imag=img;
Se(img<0)
{
imag=-imag;
cout<<real<<"-i"<<imag;
} else cout<<real<<"+i"<<img;
}
int main()
{
complexo c1,c2,c3;
c1=complexo(2,5,3,5);
c3=c1+c2;
c3.display();
retorno 0;
}
Sobrecarregando operadores binários usando amigos
1. Substitua a declaração de função de membro pela declaração de função de amigo no operador complexo
amigo de classe+(complexo, complexo)
2. Redefina a função do operador da seguinte maneira:
operador complexo+(complexo a, complexo b)
{
complexo de retorno((a.x+b.x),(a.y+b.y));
}
Escreva um programa para sobrecarregar operadores aritméticos em números complexos usando a
função amiga #include<iostream.h>
complexo de classes
{
flutuar real, img;
público:
complex(){ }
{
real=x;
img=y;
}
amigo operador complexo+(complexo);
};
operador complexo+(complexo c1, complexo c2)
{
temperatura complexa;
temp.real=c1.real+c2.real;
temp.img=c1.img+c2.img;
temperatura de retorno;
}
{
Se(img<0)
{
img=-img;
cout<<real<<"-i"<<img;
}
mais
cout<<real<<"+i"<<img;
}
int main()
{
complexo c1,c2,c3;
c3=c1+c2;
c3.display();
retorno 0;
}
UNIDADE -5
Modelos e tratamento de exceções:

Introdução, Modelos de Classe, Modelos de Classe com Vários Parâmetros, Modelos de Função, Modelos
de Função com Vários Parâmetros, Modelos de Função de Membro. Tratamento de exceções:Noções
básicas de tratamento de exceções, Tipos de exceções, mecanismo de manipulação de exceções,
mecanismo de lançamento e captura, relançamento de uma exceção, especificação de exceções.
PROGRAMAÇÃO GENÉRICA(Templates)
Programação genérica é uma abordagem onde tipos genéricos são usados como parâmetros em algoritmos para
que eles funcionem para uma variedade de tipos de dados e estruturas de dados adequados.
Um benefício significativo da programação orientada a objetos é a reutilização do código, que elimina
a codificação redundante. Um recurso importante do C++ chamado templates fortalece esse benefício da OOP
e fornece grande flexibilidade à linguagem. Os modelos suportam programação genérica, o que permite
desenvolver componentes de software reutilizáveis, como funções, classes etc. Suporte a diferentes tipos de
dados em uma única estrutura.
Conceito de Templates
Introdução
Em vez de escrever funções diferentes para os diferentes tipos de dados, podemos definir
função. Por exemplo
int máx (int a,int b); Retorna no máximo dois inteiros float
max (flutuador a, flutuador b); Retorno máximo de dois flutuadores char max (char a,char b); Retorna no
máximo dois caracteres (isso é chamado de sobrecarga de função)
Mas, em vez de escrever três funções diferentes como acima, o C++ forneceu o recurso chamado "Templates".
Com a ajuda de modelos, você pode definir apenas uma função comum da seguinte maneira:
T máx (T a,T b); T é chamado de tipo de dados genérico
Funções de modelo são a maneira de fazer resumos de função/classe criando o comportamento da função sem
saber quais dados serão manipulados por uma função. Em certo sentido, isso é o que é conhecido como
"funções genéricas ou programação".
A função de modelo é mais focada no pensamento algorítmico do que em um meio específico de um único
tipo de dados. Por exemplo, você pode criar uma função de push de pilha modelada. Essa função push pode
manipular a operação de inserção em uma pilha em qualquer tipo de dados, em vez de ter que criar uma função
de push de pilha para cada tipo diferente.
Sintaxe:
tipo de classe < modelo >
ret_type fun_name(lista de parâmetros)
{
--------------corpo de função
} //www.suhritsolutions.com
Características dos modelos:-

1. Elimina código redundante
2. Ele melhora a reutilização do código.
3. Proporciona grande flexibilidade à linguagem
Os modelos são classificados em dois tipos. São eles:
1 . Modelos de função
2 . Modelos de classe.
Modelos de função
Os modelos declarados para funções são chamados de modelos de função. Um modelo de função define como
uma função individual pode ser construída.
Sintaxe:
tipo de classe < modelo,......... >
ret _type fun_ nome(argumentos)
{
-----------------corpo da função
-----------------
}
MODELOS DE CLASSE
Os modelos declarados para classes são chamados de modelos de classe. Um modelo de classe
especifica como classes individuais podem ser construídas de forma semelhante à especificação de classe
normal. Essas classes modelam uma classe genérica que oferece suporte a operações semelhantes para
diferentes tipos de dados. Forma geral de um modelo de classe
template <classe T> classe class-name {
…; ….
}
Uma classe criada a partir de um modelo de classe é chamada de classe de modelo. A sintaxe para definir um
objeto de uma classe de modelo é:
classname<type> objectname(arglist);
#include<conio.h>
modelo <classe T> troca de classe
{
T a,b;
público:
swap (T x, T y)
{
a=x;
b=y;
}
swapab nulo()
{
T temp;
temp=a;
a=b;
b=temp;
}
void showdata()
{
Cout<<A<<B;
}
};
void principal()
{
Int M,N;
flutuador m1,n1;
cout<<"Inserir valores inteiros";
cin>>m>>n;
cout<<"Inserir valores flutuantes";
cin>>m1>>n1;
swap<int> c1(m,n);
swap<flutuação> c2(m1,n1);
c1.swapab();
c1.ShowData();
c2.swapab();
c2.showdata();
}
Modelo de classe com vários parâmetros
Sintaxe:
modelo <classe T1, classe T2,....> nome da classe

{}
#include<iostream.h> modelo <classe T1,classe T2> Teste

{
T1 a;
T2 b;
público:
Teste (T1 x, T2 y)
{ a=x; b=y;
}
void show()
{
Cout<<A<<B;
}
};
void principal()
{
Teste<flutuação,int> teste1(1.23,123);
Test<int,char> test2(100,‟w‟);
teste1.show();
teste2.mostrar();
}
MODELOS DE FUNÇÃO
Como o modelo de classe, também podemos definir modelos de função que seriam usados para criar uma
família de funções com diferentes tipos de argumento.
Formulário Geral:
modelo <classe T>
return-type function-name (argumentos do tipo T)
{}
modelo<classe T>
troca nula (T &x, T &y)
{
T temp = x;
x=y;
y=temp;
}
Void Fun(Int M, Int N, Float A, Float B)
{
Cout<<M<<N;
permuta (m,n);
Cout<<M<<N;
Cout<<A<<B;
permuta(a,b);
Cout<<A<<B;
}
int main()
{
diversão (100.200,11.22,33.44);
retorno 0;
}
Exemplo 2:-
modelo
T máx (T a, T b)
{
se(a>b)
retorno a;
mais
retorno b;
}
void principal( )
{
char ch1,ch2,ch3;
cout<<"digite dois caracteres"<< ch2<< ch3;
cin>>ch2>>ch3;
d=máx(ch2,ch3);
cout<<"max(ch2,ch3)"<< ch1;
Int A,B,C;
cout<<"insira dois inteiros:";
cin>>a>>b;
c=máx(a,b);
cout<<"max(a,b):"<< c<< endl;
flutuador f1,f2,f3;
cout<<"Digite dois flutuadores< F1F2 >:";
cin>>f1,f2;
f3=máx(f1,f2);
cout<<"max(f1,f2):"<< f3;
}
saída:
digite dois caracteres: A,B
max (ch2, ch3): B
Digite dois inteiros:20,10
max (a,b): 20
Digite dois flutuadores: 20.5,30.9
máximo (f1, f2): 30.9
Modelo de função com vários parâmetros

Como a classe de modelo, podemos usar mais de um tipo de dados genérico na instrução de modelo, usando
uma lista separada por vírgulas, conforme mostrado abaixo:
modelo <classe T1, classe T2,.> função do tipo retorno-
name(argumentos dos tipos T1,T2.) {
#inlcude<string.h>
modelo<clas T1, classe T2> void display(T1 x,T2 y) {
Cout<<X<<Y;
}
int main()
{
exibição (1999, "EBG");
exibição(12.34,1234);
retorno 0;
}
Tratamento de exceções
Exceções: As exceções são anomalias de tempo de execução ou condições incomuns que um programa pode
encontrar durante a execução do . As anomalias podem incluir condições como divisão por zero, acesso a uma
matriz fora de seus limites ou falta de memória ou espaço em disco. Quando um programa encontra uma
condição de exceção, ele deve ser identificado e manipulado.
As exceções fornecem uma maneira de transferir o controle de uma parte de um programa para outra.
A manipulação de exceções do C++ é baseada em três palavras-chave: try, catch e throw.
Tipos de exceções:Há dois tipos de exceções

1.Exceções síncronas
2.Exceções assíncronas
1.Exceções síncronas:Erros como "Índice fora do intervalo" e "Excesso de fluxo" são exceções síncronas
2.Exceções assíncronas: Os erros gerados por qualquer evento além do controle do programa são chamados de
exceções assíncronas
O objectivo do tratamento de excepções é fornecer um meio para detectar e comunicar uma circunstância
excepcional
Mecanismo de Tratamento de Exceções:

Diz-se que uma exceção é lançada no local onde algum erro ou condição anormal é detectado. O lançamento
fará com que o fluxo normal do programa seja abortado, em uma exceção elevada. Uma exceção é lançada
programática, o programador especifica as condições de um lançamento.
Nas exceções tratadas, a execução do programa será retomada em um bloco de código designado,
chamado de bloco catch, que encerra o ponto de lançamento em termos de execução do programa. O bloco de
captura pode estar, e geralmente está, localizado em uma função diferente do ponto de arremesso.
A manipulação de exceções do C++ é baseada em três palavras-chave: try, catch e throw.

Try é usado para prefaciar um bloco de declarações que podem gerar exceções. Esse bloco de instruções é conhecido
como try block. Quando uma exceção é detectada, ela é lançada usando a instrução throw no bloco try. O bloco catch
captura a exceção lançada pela instrução throw no bloco try e a manipula adequadamente.
#include<iostream>
int main()
{
Int A,B;
cout<<"Insira quaisquer dois valores inteiros";
cin>>a>>b;
int x=a-b;
tentar
{
se(x!=0)
{
cout<<"Resultado(a/x)="<<a/x<<endl;
}
mais
{ lançar x;
}
}
captura(int ex)
{
cout<<"Exceção capturada:Dividir por zero \n";
}
}
MECANISMO DE ARREMESSO
Quando uma exceção é detectada, ela pode ser lançada usando a instrução throw em qualquer uma das
seguintes formas
arremesso (exceção); lançar exceção;
jogar;
MECANISMO DE CAPTURA:
O bloco de captura é o seguinte

Catch(tipo de dados arg) {
Instruções para manipulação
Exceções
}
Várias declarações de captura:
tentar
{
tente bloquear
}
captura(tipo de dados1 arg)
{
bloco de captura1
}
captura(tipo de dados2 arg)
{
bloco de captura2
} catch(tipo de dadosN arg)
{
bloco de capturaN
}
• Quando uma exceção é lançada, o manipulador de exceção é pesquisado para obter uma
correspondência apropriada.
• É possível que os argumentos de várias declarações catch correspondam ao tipo de exceção. Nesses
casos, o primeiro manipulador que corresponde ao tipo de exceção é executado
Escrever um programa para capturar várias instruções de captura

teste de vazio (int x)
{
tentar
{
se(x==1) lançar x;
mais
if(x==0) lançar 'x';
mais
se(x==-1) lançar 1,0;
cout<<"fim do bloco try"<<endl;
}
captura (char c)
{
cout<<"pegou um personagem"<<endl;
}
captura (int m)
{
cout<<"pegou um inteiro"<<endl;
}
Captura (duplo d)
{
cout<<"pegou um duplo"<<endl;
}
}
int main()
{
teste(1);
teste(0);
teste(-1);
teste(2);
retorno 0;
}
Saída:
pegou um inteiro
pegou um personagem
pegou uma dobradinha
fim do bloco try
Capture todas as exceções:
todos os tipos possíveis de excepções e, por conseguinte, podem não ser capazes de conceber manipuladores
de capturas independentes para os capturar . Em tais circunstâncias, podemos forçar uma declaração de
captura para capturar todas as exceções em vez de um determinado tipo apenas.
pega(...)
{}
Escrever um programa para capturar todas as exceções

teste de vazio (int x)
{
tentar
{
se(x==0) lançar x;
if(x==0) lançar 'x';
se(x==-1) lançar 1,0;
}
pega(...)
{
cout<<"exceção pega"<<endl;
}
}
int main()
{
teste(-1);
teste(0);
teste(1);
retorno 0;
}
Relançando uma exceção:
É possível passar a exceção capturada por um bloco catch novamente para outro manipulador de exceção.
Isso eu conheci como Re-throwing.
#include <iostream>
void MyHandler()
{ tente {
lançar "Olá";
}
Captura (Const Char*)
{
cout <<"Exceção capturada dentro de MyHandler\n";
jogar; relançar char* fora de função
}
}
int main()
{ cout<< "Início principal "<<Endl; tentar
{
MyHandler();
}
captura(const char*)
{
cout <<"Exceção capturada dentro do Main\n";
}
cout << "Fim principal";
retorno 0;
}
Especificando exceções:
Especificação de funções de restrição de exceção para lançar algumas exceções especificadas somente com o
uso de throw(exception list) no cabeçalho da função.
Formulário geral
Digite function_name(argument list) throw(exceptions -list)
{
Declarações
tente {
Declarações
}
#include <iostream>
teste de vazio (int x) lançamento (int, flutuar, char)
{
comutador (x)
{
caso 1: lance x;
quebrar;
caso 2: lançar 'x';
quebrar;
caso 3: arremesso duplo(x);
quebrar;
caso 4: lançar flutuador (x);
quebrar;
}
}
int main()
{
tentar
{
teste(4);//teste(4) conduz a terminação anormal
}
captura(int i)
{
cout <<"Caught int type exception\n";
}
captura (flutuar f)
{
cout <<"Exceção do tipo float capturado\n";
}
captura (char c)
{
cout <<"Exceção do tipo char capturado\n";
}
Captura (Duplo I)
{
cout <<"Exceção de tipo duplo capturado\n";
}
retorno 0;
}

Notas Digitais: B.Tech (I Ano - Ii Sem) (2018-19)

Enviado por

Dados do documento

Título original

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

Notas Digitais: B.Tech (I Ano - Ii Sem) (2018-19)

Enviado por

Direitos autorais:

Formatos disponíveis

PROGRAMAÇÃO ORIENTADA A OBJETOS

DEPARTAMENTO DE CSE & IT

MALLA REDDY FACULDADE DE ENGENHARIA E TECNOLOGIA (

I Ano B.Tech II SEM L T/P/D C

Conceitos de programação orientada a objetos: Paradigma orientado a objetos – diferenças entre

Visão geral da linguagem C:

Visão geral da linguagem C++:

Programação Orientada a Procedimentos Programação Orientada a Objetos

Na OOP, a sobrecarga é possível na forma de

Exemplo de Orientação a Procedimentos

Princípios( ou características) da programação orientada a objetos:

Benefícios da programação orientada a objetos (OOPs)

Modificabilidade: é fácil fazer pequenas alterações na representação de dados ou nos procedimentos em

3. SEÇÃO DE DEFINIÇÃO : Ele é usado para declarar algumas constantes e atribuir-lhes

Int I; Esta declaração é feita fora e antes de main()

5. SUBPROGRAMA OU SEÇÃO DE FUNÇÃO: Este tem todos os subprogramas ou as funções que o

Espaço de nome definido pelo usuário:

usando exemplo de namespace;

Tipos de dados primários:

Inteiros assinados: (máquina de 16 bits):

15 14 13 12 11 10 9 8 7 -1*2 +1*2 +1*2 +1*2 +1*2 +1*2 +1*2 +1*2

-32768 -2.147.843.648 para

Tipo de dados de caractere: (char)

Tipo de dado MEMÓRIA NECESSÁRIA OU GAMA FORMATO DO ESPÉCIME

Tipos de ponto flutuante:

Exemplos de identificadores inválidos: $amount, ³num', grand-total, soma de dígitos, 4num.

Variáveis:Um local de memória nomeado é chamado de variável.

> Não devemos usar palavras-chave como identificadores.

Eles podem ser precedidos por um sinal opcional + ou ±.

Inteiro octal: Consiste em conjunto de dígitos, de 0 a 7.

Inteiro hexadecimal: Consiste em conjunto de dígitos, 0 a 9 e alfabetos A, B, C, D, E e F. Inteiro hexadecimal é

Sequência de fuga Personagem

Os operadores C podem ser classificados como

1. OPERADORES ARITMÉTICOS : Todos os operadores aritméticos básicos estão presentes no operador C.

2. OPERADORES RELACIONAIS : Muitas vezes comparamos duas grandezas e, dependendo de sua

> é menor que

Tabelas verdade para AND (&) e OR (operadores de ID : X Y X&Y X/Y

Vantagens de usar operador de atribuição taquigráfica:

Um operador ternário requer dois operandos para operar

Operador OR bit a bit ( |)

Bitwise EXCLUSIVE OU operador ( A )

Operador de deslocamento bit a bit para a esquerda

Ex: int a=2;

O operador de vírgula (,)

Primeiro atribui o valor 10 a x, depois atribui 20 a y e fina

Sno Operador Símbolo

8.6 Operador de resolução de copa:

3. Ponteiro para operador membro .*

Instruções de controle:-O fluxo de execução de instruções em um programa é chamado de controle. A

/*maior de dois números*/

/*maior de dois números*/

cout<<"B é maior que A\n A="<<b;

A INSTRUÇÃO SWITCH ou SELEÇÃO MULTIDIRECIONAL :

/*programa para simular uma calculadora simples */ #include<iostream.h>

cout<<"Digite o número 1 do operador2 : ";

Instruções ou repetições de controle de malha:

c programa para encontrar a soma de n números naturais */

cout<<"Soma dos primeiros"<<n<"números naturais é:"<<soma<<endl; retorno 0;

2 . FAZER ENQUANTO AFIRMAR:

tlo-while — (Saída controlada)

/*c programa para encontrar soma de n números naturais */

/*c programa para encontrar soma de n números naturais */

cout<<"Soma dos primeiros"<<n<<" números naturais é:%d"<<soma; retorno 0;

15 14 13 12 11 10 9 8 7 -12 +12 +12 +12 +12 +12 +12 +12

/maior de dois números/

/maior de dois números/

/programa para simular uma calculadora simples / #include<iostream.h>

/c programa para encontrar soma de n números naturais /

/c programa para encontrar soma de n números naturais /

/programa para imprimir números primos até um determinado número/

/c programa para encontrar soma de n números naturais /