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*
signed: -128 to 127
char Character or small integer. 1byte
unsigned: 0 to 255
short int signed: -32768 to 32767
Short Integer. 2bytes
( short) unsigned: 0 to 65535
signed: - 2147483648 to
2147483647
int I nteger. 4bytes
unsigned: 0 to
4294967295
signed: - 2147483648 to
long int 2147483647
Long integer. 4bytes
( long) unsigned: 0 to
4294967295
Boolean value. I t can take one of two
bool 1byte true or false
values: true or false.
float Floating point number. 4bytes +/- 3.4e +/- 38 (~7 digits)
+/- 1.7e +/- 308 (~15
double Double precision floating point number. 8bytes
digits)
long double Long double precision floating point 8bytes
+/- 1.7e +/- 308 (~15
number. digits)
2 or 4
wchar_t Wide character. 1 wide character
bytes
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
\n Newline
\r carriage return
\t Tab
\v vertical tab
\b Backspace
\f form feed (page feed)
\a alert
\a alert (beep)
(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) { if (x == 1) {
  case 1:   cout << "x is 1";
    cout << "x is 1";   }
    break; else if (x == 2) {
  case 2:   cout << "x is 2";
    cout << "x is 2";   }
    break; else {
  default:   cout << "value of x
    cout << "value of x    unknown";
    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 a multiplicaçã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;
}