Linguagem e Programação c++

Prévia do material em texto

Introdução à linguagem de 
programação C++
Tulio Marcus R. Calixto
Centro de Informática de Ribeirão Preto
Estrutura de um programa
// my first program in C++
#include <iostream>
using namespace std;
int main ()
{
  cout << "Hello World!";
  return 0;
}
Estrutura de um programa
// my first program in C++
Comentário de linha;
● Todas as linhas começando com 2 barras (//) 
serão comentários e não terão nenhum efeito no 
comportamento do programa;
● O programador pode usar para incluir pequenas 
observações ou explicações dentro do código.
Estrutura de um programa
#include <iostream>
● Linhas começando com # são directivas para o 
pré­processador;
● Diz para o pré­processador incluir o arquivo 
iostream;
● Biblioteca em C++ para entrada e saída básica. 
Suas funções serão usadas no decorrer do 
programa.
Estrutura de um programa
using namespace std;
● Todos os elementos de bibliotecas padrão C++ 
são declaradas dentro de um namespace chamado 
std;
● Para acessar suas funcionalidades nós a 
declaramos com esta expressão.
Estrutura de um programa
int main ()
● Inicio da função principal;
● É sempre a primeira função a ser executada;
● A função principal é o ponto de partida para 
execução de todos os programas C++
Estrutura de um programa
cout << "Hello World!";
● cout representa o fluxo de saída padrão em C++;
● cout é declarado dentro de iostream dentro do 
namespace std;
● ; indica o fim de uma instrução C++
Estrutura de um programa
return 0;
● Indica que a função terminou;
● O código de retorno 0 indica que o programa 
trabalhou como esperado – sem erros;
Estrutura de um programa
/* my second program in C++
   with more comments */
#include <iostream>
using namespace std;
int main ()
{
  cout << "Hello World! ";          // prints Hello World!
  cout << "I'm a C++ program"; // prints I'm a C++ 
program
  return 0;
}
Variáveis e tipos de dados
● Variáveis: Uma parte da memória para armazenar 
um determinado valor;
● O computador pode armazenar milhões de 
variáveis e executar cálculos sofisticados com 
elas;
● Cada variável precisa de um identificador que 
distingue uma de outra;
Variáveis e tipos de dados
Identificadores:
● Um identificador válido é uma sequência de uma 
ou mais letras, números ou underscore ( _ ) ;
● Não pode haver espaços, símbolos ou caracteres 
de pontuação;
● Precisam sempre começar com uma letra;
● Não pode ser uma palavra­chave
Variáveis e tipos de dados
● Palavra­chave: Palavras reservadas da linguagem C++
  asm, auto, bool, break, case, catch, char, class, const, const_cast, 
continue, default, delete, do, double, dynamic_cast, else, enum, 
explicit, export, extern,  false,  float,  for,  friend, goto,  if,  inline, 
int,  long,  mutable,  namespace,  new,  operator,  private, 
protected,  public,  register,  reinterpret_cast,  return,  short, 
signed,  sizeof,  static,  static_cast,  struct,  switch,  template,  this, 
throw,  true,  try,  typedef,  typeid,  typename,  union,  unsigned, 
using, virtual, void, volatile, wchar_t, while 
Variáveis e tipos de dados
● C++ é case sensitive: faz distinção entre letras 
maiúsculas e minúsculas;
● Para usar uma variável em C++ nós precisamos 
primeiro especificar o tipo de dado que a variável 
irá possuir seguida de um identicador de variável 
válido;
Ex.: int a
       float mynumber
Variáveis e tipos de dados
● Se desejamos declarar várias variáveis de um 
mesmo tipo, podemos fazer tudo numa mesma 
linha.
Ex.: int a, b, c
Variáveis e tipos de dados
// operating with variables
#include <iostream>
using namespace std;
int main ()
{
  // declaring variables:
  int a, b;
  int result;
Variáveis e tipos de dados
Name Description Size* Range*
char Character or small integer. 1byte signed: -128 to 127unsigned: 0 to 255
short int
(short) Short Integer. 2bytes
signed: -32768 to 32767
unsigned: 0 to 65535
int Integer. 4bytes
signed: -2147483648 to
2147483647
unsigned: 0 to
4294967295
long int
(long) Long integer. 4bytes
signed: -2147483648 to
2147483647
unsigned: 0 to
4294967295
bool Boolean value. I t can take one of twovalues: true or false. 1byte true or false
float Floating point number. 4bytes +/- 3.4e +/- 38 (~7 digits)
double Double precision floating point number. 8bytes +/- 1.7e +/- 308 (~15digits)
long double Long double precision floating pointnumber. 8bytes
+/- 1.7e +/- 308 (~15
digits)
wchar_t Wide character. 2 or 4bytes 1 wide character
Variáveis e tipos de dados
  // process:
  a = 5;
  b = 2;
  a = a + 1;
  result = a ­ b;
  // print out the result:
  cout << result;
  // terminate the program:
  return 0;
}
Variáveis e tipos de dados
● Escopo de variáveis: Local onde a variável pode 
ser vista.
● Variável global: São variáveis declaradas no 
corpo principal do código for a de todas as 
funções
● Variável local: É declarada dentro do corpo de 
uma função ou bloco
Variáveis e tipos de dados
Variáveis e tipos de dados
● Inicialização de variáveis: Quando declaramos 
uma variável seu valor default é indeterminado.
● Se quisermos que a variável armazene algum 
valor concreto, nós devemos inicializar a 
variável.
Ex.: int a = 0;
       int a (0);
Variáveis e tipos de dados
// initialization of variables
#include <iostream>
using namespace std;
int main ()
{
  int a=5;               // initial value = 5
  int b(2);              // initial value = 2
  int result;            // initial value undetermined
Variáveis e tipos de dados
  a = a + 3;
  result = a ­ b;
  cout << result;
  return 0;
}
Variáveis e tipos de dados
● Strings: sequencia de caracteres.
● C++ prove suporte para strings através da classe 
string.
● Para declarar um tipo de dado string nós devemos 
incluir uma informação adicional no arquivo de 
cabeçalho: <string>
Variáveis e tipos de dados
// my first string
#include <iostream>
#include <string>
using namespace std;
int main ()
{
  string mystring;
  mystring = "This is the initial string content";
  cout << mystring << endl;
Variáveis e tipos de dados
  mystring = "This is a different string content";
  cout << mystring << endl;
  return 0;
}
Constantes
● Constantes são expressões com um valor fixo;
Ex.: #define PI 3.141592625
       #define NEWLINE '\n'
Directiva do préprocessador
const int x = 100;
const char tabulator = '\t';
Directiva da linguagem
Constantes
// defined constants: calculate circumference
#include <iostream>
using namespace std;
#define PI 3.14159
#define NEWLINE '\n'
int main ()
{
Constantes
  double r=5.0;               // radius
  double circle;
  circle = 2 * PI * r;
  cout << circle;
  cout << NEWLINE;
  return 0;
}
Constantes
\nNewline
\r carriage return
\tTab
\vvertical tab
\bBackspace
\f form feed (page feed)
\aalert (beep)\aalert (beep)
\' single quote (')
\"double quote (")
\?question mark (?)
\\backslash (\)
Operadores
● A partir do momento que possuimos variáveis 
nós podemos realizar operações com elas.
● Operador de atribuição
– a = 5;
– c = 90;
Operadores
// assignment operator
#include <iostream>
using  namespace std;
int  main ()
{
  int  a, b;         // a:?,  b:?
  a = 10;           // a:10, b:?
  b = 4; // a:10, b:4
  a = b; // a:4,  b:4
Operadores
   b = 7;            // a:4,  b:7
  cout << "a:";
  cout << a;
  cout << " b:";
  cout << b;
  return  0;
}
Operadores
● Aritiméticos
+ addition
- subtraction
* multiplication
/ division
% modulo
Operadores
● Operadores compostos:+=, ­=, *=, /=, %=, >>=, <<=, &=, ^=, |=
● Realizam a operação seguida de atribuição
Operadores
// compound assignment operators
#include <iostream>
using namespace std;
int main ()
{
  int a, b=3;
  a = b;
  a+=2;             // equivalent to a=a+2
  cout << a;
  return 0;
}
Operadores
● Incremento e Decremento (++, ­­)
c++;
c+=1;
c=c+1;
Operadores
● Operadores de igualdade
==, !=, >, <, >=, <=
Ex:
(7 == 5)     // evaluates to false.
(5 > 4)      // evaluates to true.
(3 != 2)     // evaluates to true.
(6 >= 6)     // evaluates to true.
(5 < 5)      // evaluates to false.
Operadores
● Operadores lógicos
!, &&, || 
Ex:
!(5 == 5) // evaluates to false because the expression at its right (5 == 5) is true. 
!(6 <= 4)    // evaluates to true because (6 <= 4) would be false. 
!true        // evaluates to false
!false       // evaluates to true
Operadores
● Operador &&
a   b a && b
true true true
true false false
false true false
false false false
Operadores
● Operador ||
a    b a || b
true true true
true false true
false true true
false false false
Operadores
● Operador condicional ( ? )
● Retorna um valor se a expressão é verdadeira e 
outro valor se a expressão for falsa.
● Sintaxe: condition ? result1 : result2
Ex:
7==5 ? 4 : 3     // returns 3, since 7 is not equal to 5.
7==5+2 ? 4 : 3   // returns 4, since 7 is equal to 5+2.
Operadores
// conditional operator
#include <iostream>
using namespace std;
int main ()
{
  int a,b,c;
  a=2;
  b=7;
  c = (a>b) ? a : b;
  cout << c;
  return 0;
}
Entrada e Saída básica
● Permite o usuário interagir com o sistema.
● C++ usa streams para realizar entrada e saida 
básica de forma sequencial, como no teclado, por 
exemplo.
● stream é um objeto onde o programa pode inserir 
ou extrair caracteres. 
● O arquivo de cabeçalho IOSTREAM contem os 
objetos de entrada e saida padrão.
Entrada e Saída básica
● Saída padrão ­> monitor
● Objeto stream definido para acessar a saída: cout
Ex:
cout << "First sentence.\n ";
cout << "Second sentence.\nThird sentence."; 
Entrada e Saída básica
● Entrada padrão: teclado
● Objeto stream definido: cin
● Precisa ser seguido de uma variável
Ex:
int age;
cin >> age; 
Entrada e Saída básica
// i/o example
#include <iostream>
using namespace std;
int main (){
  int i;
  cout << "Please enter an integer value: ";
  cin >> i;
  cout << "The value you entered is " << i;
  cout << " and its double is " << i*2 << ".\n";
  return 0;   }
Entrada e Saída básica
● cin e strings
● cin pára quando encontra um espaço em branco
● Só é possi entrar palavra por palavra
● Solução: getline
Entrada e Saída básica
// cin with strings
#include <iostream>
#include <string>
using namespace std;
int main ()
{
  string mystr;
  cout << "What's your name? ";
  getline (cin, mystr);
Entrada e Saída básica
 cout << "Hello " << mystr << ".\n";
  cout << "What is your favorite team? ";
  getline (cin, mystr);
  cout << "I like " << mystr << " too!\n";
  return 0;
}
Entrada e Saída básica
● stringstream.
● O arquivo de cabeçalho <sstream> define uma 
classe chamada stringstream.
● Permite tratar objetos strings como streams.
● Pode ser utilizado para converter strings em int e 
double
Entrada e Saída básica
Ex:
// stringstreams
#include <iostream>
#include <string>
#include <sstream>
using namespace std;
int main ()
{ 
Entrada e Saída básica
  string mystr;
  float price=0;
  int quantity=0;
  cout << "Enter price: ";
  getline (cin,mystr);
  stringstream(mystr) >> price;
  cout << "Enter quantity: ";
  getline (cin,mystr);
  stringstream(mystr) >> quantity;
Entrada e Saída básica
 cout << "Total price: " << price*quantity << endl;
  return 0;
}
Estruturas de Controle
● Um programa não é limitado a uma sequencia 
linear de instuções.
● Pode haver bifurcações, repetição de código e 
tomada de decisão.
● Especificam como o programa deve reagir em 
determinadas circunstâncias.
Estruturas de Controle
● Com a adição de estruturas de controle segue um 
novo conceito: bloco.
● Bloco: Conjunto de instruções agrupadadas e 
deliminadas por colchetes {}
● Se o bloco for de apenas uma instrução pode­se 
otimir o {}
Estruturas de Controle
● if / else
● If (condição) bloco de instruções
● Se a condição é verdadeira o bloco de instruções 
é executado.
● Se a condição é falsa o bloco é ignorado e o 
programa continua após o bloco condicional.
Estruturas de Controle
Exs.
if (x == 100)
  cout << "x is 100";
if (x == 100){
   cout << "x is ";
   cout << x;
}
Estruturas de Controle
● Nós podemos especificar o que nós queremos que 
aconteça caso a condição não seja satisfeita. Para 
tal utilizamos a palavra reservada: else
Ex:
if (x == 100)
  cout << "x is 100";
else
  cout << "x is not 100";
Estruturas de Controle
● Concatenando instruções if + else
Ex:
if (x > 0)
  cout << "x is positive";
else if (x < 0)
  cout << "x is negative";
else
  cout << "x is 0";
Estruturas de Controle
● Loops: tem o propósito de repetir o bloco de 
instruções um certo número de vezes ou enquanto 
uma condição não for estabelecida.
● Loop while
● Sintaxe: while (condição) bloco de instruções
Estruturas de Controle
// custom countdown using while
#include <iostream>
using namespace std;
int main ()
{
  int n;
  cout << "Enter the starting number > ";
  cin >> n;
Estruturas de Controle
  while (n>0) {
    cout << n << ", ";
    ­­n;
  }
  cout << "FIRE!\n";
  return 0;
}
Estruturas de Controle
● Loop: do .. while
● Semelhante ao loop while, exceto que a condição 
é testada depois da execução do bloco.
● Garante que o bloco seja executado pelo menos 
uma vez.
Estruturas de Controle
Ex.:
// number echoer
#include <iostream>
using namespace std;
int main ()
{
  unsigned long n;
Estruturas de Controle
  do {
    cout << "Enter number (0 to end): ";
    cin >> n;
    cout << "You entered: " << n << "\n";
  } while (n != 0);
  return 0;
}
Estruturas de Controle
● Loop: for
● Sintaxe: 
– for (inicialização; condição; incremento) bloco;
● Realização uma ação repetitiva com um contador 
que é inicializado e incrementado em cada 
iteração.
Estruturas de Controle
Ex.:
// countdown using a for loop
#include <iostream>
using namespace std;
int main (){
  for (int n=10; n>0; n­­) {
    cout << n << ", ";
  }
Estruturas de Controle
  cout << "FIRE!\n";
  return 0;
}
Estruturas de Controle
● Saltos de blocos
● Break
● Usando o break podemos deixar o loop for, se a 
condição do mesmo não é satisfeita;
● Podemos usar para terminar um loop infinito;
● Forçar o fim antes do fim natural
Estruturas de Controle
Ex.:
// break loop example
#include <iostream>
using namespace std;
int main ()
{
  int n;
Estruturas de Controle
  for (n=10; n>0; n­­)  {
    cout << n << ", ";
    if (n==3)
    {
      cout << "countdown aborted!";
      break;
    }
  }
  return 0;
}
Estruturas de Controle
● Continue
● Faz o programa ignorar o restante do loop atual e 
passa para a proxima iteração.
● Ex.:
Estruturas de Controle
// continue loop example
#include <iostream>
using namespace std;
int main (){
  for (int n=10; n>0; n­­) {
    if (n==5) continue;
    cout << n << ", ";
  }
  cout << "FIRE!\n";
  return 0;   
}
Estruturas de Controle● Goto
● Permite fazer um salto para um outro ponto do 
programa.
● O destino do salto precisa ter um identificador 
que é utilizado como argumento para o comando 
goto.
● O identificador válido é seguido por dois pontos 
(:).
Estruturas de Controle
Ex.:
// goto loop example
#include <iostream>
using namespace std;
int main ()
{
  int n=10;
  loop:
Estruturas de Controle
  cout << n << ", ";
  n­­;
  if (n>0) goto loop;
  cout << "FIRE!\n";
  return 0;
}
Estruturas de Controle
● Switch
● Tem a função de checar muitas opções para poder 
tomar uma decisão;
● Pode ser usado no lugar de vários if else
● Sintaxe:
Estruturas de Controle
switch (expression){
  case constant1:
     group of statements 1;
     break;
  case constant2:
     group of statements 2;
     break;
. . .
  default:
     default group of statements
}
Estruturas de Controle
switch (x) {
  case 1:
    cout << "x is 1";
    break;
  case 2:
    cout << "x is 2";
    break;
  default:
    cout << "value of x 
    unknown";
  }
if (x == 1) {
  cout << "x is 1";
  }
else if (x == 2) {
  cout << "x is 2";
  }
else {
  cout << "value of x
  unknown";
  }
Funções
● Utilizando funções podemos estruturar nosso 
programa de forma mais modular.
● Função é um grupo de instruções que são 
executadas quando chamadas em algum ponto do 
programa.
● Sintaxe:
– tipo nome ( parametro1, parametro2, ...) 
{ instruções }
Funções
● Onde:
– Tipo: Tipo de dado retornado pela função
– Nome: Identificador pelo qual será possivel chamar a 
função
– Parametros: Cada parametro consiste em um tipo de 
dado específico seguido por um identificador
– Instruções: Formam o corpo da função
Funções
Ex.:
// function example
#include <iostream>
using namespace std;
int addition (int a, int b){
  int r;
  r=a+b;
  return (r);
}
Funções
int main ()
{
  int z;
  z = addition (5,3);
  cout << "The result is " << z;
  return 0;
}
Funções
Ex.2:
// function example
#include <iostream>
using namespace std;
int subtraction (int a, int b){
  int r;
  r=a­b;
  return (r);
}
Funções
int main (){
  int x=5, y=3, z;
  z = subtraction (7,2);
  cout << "The first result is " << z << '\n';
  cout << "The second result is " << subtraction (7,2) << '\n';
  cout << "The third result is " << subtraction (x,y) << '\n';
  z= 4 + subtraction (x,y);
  cout << "The fourth result is " << z << '\n';
  return 0;
}
Funções
● Funções sem tipo: void
● Função que exibe uma mensagem na tela
● Ex.:
Funções
// void function example
#include <iostream>
using namespace std;
void printmessage (){
  cout << "I'm a function!";
}
int main ()
{
  printmessage ();
  return 0;
}
Funções
● Argumentos podem ser passador por valor ou por 
referência
● Até agora os argumentos foram passados por 
valor
int x=5, y=3, z;
z = addition ( x , y );
Funções
● Passamos os valores de x e y (5, 3) e não as 
variáveis x e y
● Os valores das variáveis a e b passam a ser 5 e 3
● Modificações nos valores de a e b não modificam 
os valores de x e y, pois apenas cópias dos 
valores foram passados para a função.
● Se quisermos que os valores de x e y sejam 
modificados precisamos passar os dados por 
referência
Funções
// passing parameters by reference
#include <iostream>
using namespace std;
void duplicate (int& a, int& b, int& c){
  a = a * 2;
  b = b * 2;
  c = c * 2;
}
Funções
int main ()
{
  int x=1, y=3, z=7;
  duplicate (x, y, z);
  cout << "x=" << x << ", y=" << y << ", z=" << z;
  return 0;
}
Funções
● Na declaração da função os tipos de dados de 
cada parametro são seguidos por um sinal &
● & indica que os paramentros são passados por 
referência
Funções
Ex.2:
// more than one returning value
#include <iostream>
using namespace std;
void prevnext (int x, int& prev, int& next){
  prev = x­1;
  next = x+1;
}
Funções
int main ()
{
  int x=100, y, z;
  prevnext (x, y, z);
  cout << "Previous=" << y << ", Next=" << z;
  return 0;
}
Funções
● Valores padrões em paramentros
● Quando declaramos uma função podemos usar 
valores default para os parametros
● O valor default será usado se o argumento 
correspondente for deixado em branco quando a 
função é chamada.
● Se os valores forem passados para a função, os 
valores default serão ignorados
Funções
// default values in functions
#include <iostream>
using namespace std;
int divide (int a, int b=2){
  int r;
  r=a/b;
  return (r);
}
Funções
int main ()
{
  cout << divide (12);
  cout << endl;
  cout << divide (20,4);
  return 0;
}
Funções
● Sobrecarga de funções 
● Em C++ duas funções podem ter o mesmo nome, 
se:
– Possuírem tipo e ou número de parametros diferentes
Funções
Ex.:
// overloaded function
#include <iostream>
using namespace std;
int operate (int a, int b){
  return (a*b);
}
float operate (float a, float b){
  return (a/b);
}
Funções
int main (){
  int x=5,y=2;
  float n=5.0,m=2.0;
  cout << operate (x,y);
  cout << "\n";
  cout << operate (n,m);
  cout << "\n";
  return 0;
}
Funções
● Recursividade
● Propriedade que as funções têm de chama­se a si 
mesmo.
● Cálculo de fatorial
● Ordenação
Funções
Ex.:
// factorial calculator
#include <iostream>
using namespace std;
long factorial (long a){
  if (a > 1)
   return (a * factorial (a­1));
  else
   return (1);
}
Funções
int main ()
{
  long number;
  cout << "Please type a number: ";
  cin >> number;
  cout << number << "! = " << factorial (number);
  return 0;
}
Funções
● Declarando funções
● Funções precisam ser declaradas antes de serem 
chamadas
● Até agora a função main era construído depois de 
todas as outras funções
● Solução: declarar as funções
Funções
Ex.:
// declaring functions prototypes
#include <iostream>
using namespace std;
void odd (int a);
void even (int a);
Funções
int main (){
  int i;
  do {
    cout << "Type a number (0 to exit): ";
    cin >> i;
    odd (i);
  } while (i!=0);
  return 0;
}
Arrays
● Conjunto de elementos do mesmo tipo de dado
● Localizados em regiões de memória contígua
● Podem ser referenciados individualmente através 
de um identificador
Arrays
● Declarando arrays
– int billy [5];
● Inicializando arrays
– int billy [5] = { 16, 2, 77, 40, 12071 };
● Acessando elemento
– a = billy[2];
Arrays
 
Arrays
Ex.:
// arrays example
#include <iostream>
using namespace std;
int billy [] = {16, 2, 77, 40, 12071};
int n, result=0;
Arrays
int main ()
{
  for ( n=0 ; n<5 ; n++ )
  {
    result += billy[n];
  }
  cout << result;
  return 0;
}
Arrays
● Arrays multidimensionais
● Declaração
– int jimmy [3][5];
Arrays
● Acessando elemento
– int a = jimmy [1][3];
Arrays
Ex.:
#define WIDTH 5
#define HEIGHT 3
int jimmy [HEIGHT][WIDTH];
int n,m;
Arrays
int main (){
  for (n=0;n<HEIGHT;n++)
    for (m=0;m<WIDTH;m++)
    {
      jimmy[n][m]=(n+1)*(m+1);
    }
  return 0;
}
Arrays
● Gerar números aleatórios:
– numero= rand() % valor_maximo; 
● Precisa do arquivo de cabeçalho:
– #include <stdlib.h>
Arrays
● Exercício:
● Crie uma matriz quadrada 10x10
● Insira todos os elementos randomicamente
● Exiba o resultado da multiplicação dos elementos 
da diagonal principal MENOS amultiplicação 
dos elementos da diagonal secundária da matriz
Arrays
● Dicas
● Diagonal Principal: linha = coluna
● Diagonal Secundária: (linha + coluna) = 
(dimensao – 1)
● Para percorrer a matriz use:
 for (linha)
    for (coluna)
Classes e Objetos
● Classe
– Definem os atributos de um objeto
– Definem o que um objeto pode fazer
● Objetos
– É a realização da classe
Classes e Objetos
Ex.:
class CRectangle {
    int x, y;
  public:
    void set_values (int,int);
    int area (void);
  } ;
Classes e Objetos
● Modificadores de acesso
● Private: Acessivel somente por membros da 
classe.
● Public: Acessivel de qualquer lugar onde o objeto 
é visivel.
Classes e Objetos
// classes example
#include <iostream>
using namespace std;
class CRectangle {
    int x, y;
  public:
    void set_values (int,int);
    int area () {return (x*y);}
};
Classes e Objetos
void CRectangle::set_values (int a, int b) {
  x = a;
  y = b;
}
int main () {
  CRectangle rect;
  rect.set_values (3,4);
  cout << "area: " << rect.area();
  return 0;
}
Classes e Objetos
● Construtor
● Metodo utilizado para inicializar as variaveis de 
um objeto
● É chamado automaticamente quando o objeto é 
criado
● Precisa ter o mesmo nome da classe e não deve 
ter nenhum dado de retorno
Classes e Objetos
● Sobre carga de construtores
// overloading class constructors
#include <iostream>
using namespace std;
class CRectangle {
    int width, height;
  public:
    CRectangle ();
    CRectangle (int,int);
    int area (void) {return (width*height);}
};
Classes e Objetos
CRectangle::CRectangle () {
  width = 5;
  height = 5;
}
CRectangle::CRectangle (int a, int b) {
  width = a;
  height = b;
}
Classes e Objetos
int main () {
  CRectangle rect (3,4);
  CRectangle rectb;
  cout << "rect area: " << rect.area() << endl;
  cout << "rectb area: " << rectb.area() << endl;
  return 0;
}
Classes e Objetos
● Herança
● Permite criar classes que são derivadas de outras 
classes
● Inclui todas as caracteristicas da classe pai + suas 
próprias
● Para indicar herença utilizamos ( : )
– class CRectangle: public CPolygon
Classes e Objetos
● Ex.:
Classes e Objetos
// derived classes
#include <iostream>
using namespace std;
class CPolygon {
  protected:
    int width, height;
  public:
    void set_values (int a, int b);
  };
void CPolygon::set_values (int a, int b){ 
  width=a; height=b;
}
Classes e Objetos
class CRectangle: public CPolygon {
  public:
    int area ();
  };
int CRectangle::area(){ 
  return (width * height); 
}
class CTriangle: public CPolygon {
  public:
    int area ();
  };
Classes e Objetos
int CTriangle::area(){ 
  return (width * height / 2);
}
  
int main () {
  int a, b, c, d;
  cout << "Informe a base do retangulo: ";
  cin >> a;
  cout << "Informe a altura do retangulo: ";
  cin >> b;
Classes e Objetos
 cout << "Informe a base do triangulo: ";
  cin >> c;
  cout << "Informe a altura do triangulo: ";
  cin >> d;
  CRectangle rect;
  CTriangle trgl;
Classes e Objetos
  rect.set_values (a, b);
  trgl.set_values (c, d);
  cout << "Area do retangulo: " << rect.area() << 
endl;
  cout << "Area do triangulo: " << trgl.area() << 
endl;
  return 0;
}
	Slide 1
	Slide 2
	Slide 3
	Slide 4
	Slide 5
	Slide 6
	Slide 7
	Slide 8
	Slide 9
	Slide 10
	Slide 11
	Slide 12
	Slide 13
	Slide 14
	Slide 15
	Slide 16
	Slide 17
	Slide 18
	Slide 19
	Slide 20
	Slide 21
	Slide 22
	Slide 23
	Slide 24
	Slide 25
	Slide 26
	Slide 27
	Slide 28
	Slide 29
	Slide 30
	Slide 31
	Slide 32
	Slide 33
	Slide 34
	Slide 35
	Slide 36
	Slide 37
	Slide 38
	Slide 39
	Slide 40
	Slide 41
	Slide 42
	Slide 43
	Slide 44
	Slide 45
	Slide 46
	Slide 47
	Slide 48
	Slide 49
	Slide 50
	Slide 51
	Slide 52
	Slide 53
	Slide 54
	Slide 55
	Slide 56
	Slide 57
	Slide 58
	Slide 59
	Slide 60
	Slide 61
	Slide 62
	Slide 63
	Slide 64
	Slide 65
	Slide 66
	Slide 67
	Slide 68
	Slide 69
	Slide 70
	Slide 71
	Slide 72
	Slide 73
	Slide 74
	Slide 75
	Slide 76
	Slide 77
	Slide 78
	Slide 79
	Slide 80
	Slide 81
	Slide 82
	Slide 83
	Slide 84
	Slide 85
	Slide 86
	Slide 87
	Slide 88
	Slide 89
	Slide 90
	Slide 91
	Slide 92
	Slide 93
	Slide 94
	Slide 95
	Slide 96
	Slide 97
	Slide 98
	Slide 99
	Slide 100
	Slide 101
	Slide 102
	Slide 103
	Slide 104
	Slide 105
	Slide 106
	Slide 107
	Slide 108
	Slide 109
	Slide 110
	Slide 111
	Slide 112
	Slide 113
	Slide 114
	Slide 115
	Slide 116
	Slide 117
	Slide 118
	Slide 119
	Slide 120
	Slide 121
	Slide 122
	Slide 123
	Slide 124
	Slide 125
	Slide 126
	Slide 127
	Slide 128
	Slide 129
	Slide 130
	Slide 131
	Slide 132
	Slide 133
	Slide 134