AprendaC Em10Anos

Aprenda C++ em 10
anos, parte 1
Eduardo Felipe Castegnaro
Projeto UPGRADE!
quinta-feira, 27 de maio de 2010

Por que 10 anos?

Dedicação semanal
30
22,5
15
7,5
0
6 8 10 12 14 16 18 20
Regular Bom Melhor

Horas acumuladas
10
7
Horas acumuladas
0
4 6 8 10 12 14 16 18 20
Idade

"Excellence in any department can be
attained only by the labor of a lifetime; it
is not to be purchased at a lesser price”
Samuel Johnson (1709-1784)

"The lyf so short, the craft so long to lerne."
Chaucer (1340-1400)

"Ars longa, vita brevis, occasio praeceps,
experimentum periculosum, iudicium
difficile"
Hippocrates (400 A.C.)

O que eu espero?
• Vocês já são programadores, mas criados

em linguagens como Java, Python e Ruby
• Não possuem experiência prévia em C ou
C++.
• Tenham 10.000 horas disponíveis para se
dedicar.

Objetivos
• Cobrir amplo território

• Mais rápido possível
• Mostrando zonas de perigo
• Mostrando grandes diferenças entre C++ e
outras linguagens

Diferenças
• Toda memória deve ser explicitamente

tratada.
• Quase nada faz nada automaticamente.

Let’s GO!

Hello, World!
#include <iostream>
int main(int argc, char* argv[])

{
std::cout << "Hello, World!" << std::endl;
return 0;
}

Executando
uniqua:~/cpp$ g++ ex1.cpp

uniqua:~/cpp$ ls -l
total 20
-rwxr-xr-x 1 edufelipe 9776 a.out
-rw-r--r--@ 1 edufelipe 118 ex1.cpp
uniqua:~/cpp$ ./a.out
Hello, World!

Compilando
• g++ compila o hello.cpp em a.out

• g++ chama o ligador para criar um
executável do arquivo objeto
• main() tem de se chamar main() ou o
ligador não cria um executável.

Hello, World!
#include <iostream>

{
return 0;
}

Hello, World!
#include <iostream>

Hello, World!

Hello, World!
{

Hello, World!
return 0;
}

Literais
• Strings são seqüencias de caracteres, entre

aspas duplas.
• Caracteres ficam entre aspas simples.

Variáveis
• Inteiros são int e podem ser unsigned.

• Ponto flutuante são float ou double
• Caracteres são char.

Strings?
• Dualidade proveniente do C
• Não existem strings em C
• Existe a classe de string em C++

#include <iostream>
#include <string>

{
std::string a = "Hello, ";
std::string b = a + "World!";
std::cout << b << std::endl;
return 0;
}

#include <iostream>
#include <string>

{
std::string a = "Hello, " + "World!";
std::cout << a << std::endl;
return 0;
}

Como assim?
uniqua:~/cpp$ g++ ex3.cpp
ex3.cpp: In function ‘int main(int, char**)’:

ex3.cpp:6: error: invalid operands of types
‘const char [8]’ and ‘const char [7]’ to
binary ‘operator+’

#include <iostream>

{
const char str[] = "Hello?";
std::cout << str << std::endl;
return 0;
}

#include <iostream>

{
const char str[] = "Hello \0 World";
return 0;
}

Funções
• Podem receber zero ou mais parêmetros

• Podem retornar zero ou um valor
• Podem receber valores por:
• Cópia
• Referência
• Ponteiro

#include <iostream>
//Declare
int square(int number);
//Define
int square(int n)
{
return n * n;
}

{
std::cout << square(2) << std::endl;
return 0;
}

#include <iostream>
//Define
void print(std::string str)
{
}

{
print("Hello World!");
return 0;
}

#include <iostream>
#include <string>
void by_copy(std::string a) {
a[0] = 'X';
}
void by_ref(std::string& a){
a[0] = 'Y';
}
int main(int argc, char* argv[]) {

std::string a = "Hello!";
by_copy(a);
by_ref(a);
return 0;
}
Namespaces
#include <iostream>
namespace first {
int var = 5;
}
namespace second {
double var = 3.1416;
}

std::cout << first::var << std::endl;
std::cout << second::var << std::endl;
return 0;
}
Perguntas?

Ponteiros
Ponteiros
• Endereço de memória, associados a um

tipo.
• Perigosos.
• Não dá pra viver sem eles.

Ponteiros
• Você pega o endereço de variáveis com &

• Você pega o conteúdo do ponteiro com *

#include <iostream>

{
int i = 5;
int* iptr = &i;
std::cout << iptr << std::endl;
std::cout << *iptr << std::endl;
*iptr = 6;
std::cout << iptr << std::endl;
std::cout << *iptr << std::endl;
return 0;
}

#include <iostream>

{
int totals[] = {1, 2, 3, 4};
int* i = totals; // &totals[0]
std::cout << *i << std::endl;
i = i + 2;
std::cout << *i << std::endl;
return 0;
}

Referências
• Ponteiros podem ser letais.

• Referências são ponteiros com restrições
• Tem de apontar para um lugar existente
• Não podem ser manipuladas diretamente

#include <iostream>
void by_pointer(int* i) {}

{
int i = 5;
int* iptr = &i;
by_pointer(iptr);
iptr = iptr + 0x5555;
by_pointer(iptr);
by_pointer(0);
return 0;
}

#include <iostream>
void by_ref(int& i) {
std::cout << i << std::endl;
}

{
int i = 5;
int& iref = i;
by_ref(iref);
iref = iref + 0x5555;
by_ref(iref);
return 0;
}

#include <iostream>
int& get_ref() {
int i = 5;
return i;
}

{
int& iref = get_ref();
std::cout << iref << std::endl;
return 0;
}

Classes!

Classes em C/C++
• C não possui classes

• struct é uma restrição
• C++ introduziu a palavra reservada class
• C++ ainda possui structs

#include <iostream>
struct item {
int pos;
};

item fst;
item snd, trd;
fst.pos = 10;
std::cout << fst.pos << std::endl;

std::cout << snd.pos << std::endl;
std::cout << trd.pos << std::endl;
return 0;
}

#include <iostream>
class item {
int pos;
public:
int get_pos() { return pos; }
void set_pos(int p){ pos = p;}
};

item fst, snd;
fst.set_pos(10);
std::cout << fst.get_pos() << std::endl;

std::cout << snd.get_pos() << std::endl;
return 0;
}
#include <iostream>
class rectangle {
public:
rectangle(int w, int h) {
_w = w;
_h = h;
}
int area() { return _w * _h; }
private:
int _w, _h;
};

rectangle rect(2, 10);
std::cout << rect.area() << std::endl;
return 0;
}
#include <iostream>
class rectangle {
public:
rectangle(int w, int h)
: _w(w), _h(h)
{
}
int area() { return _w * _h; }
private:
int _w, _h;
};

rectangle rect(2, 10);
std::cout << rect.area() << std::endl;
return 0;
}
#include <iostream>
class Car {
public:
Car(int tp)
:type(tp) {}
int type;
};
void print_car(Car c) {
std::cout << c.type << std::endl;
}

print_car(55);
return 0;
}
#include <iostream>
class Car {
public:
explicit Car(int tp)
:type(tp) {}
int type;
};
void print_car(Car c) {
std::cout << c.type << std::endl;
}

print_car(55);
return 0;
}
#include <iostream>
class Car {
public:
Car(int tp) :type(tp) {
std::cout << "Car()" << std::endl;
}
Car(const Car& c) {
type = c.type;
std::cout << "Copy Car()" << std::endl;
}
int type;
};
Car print_car(Car c) { return c; }

Car c(55);
std::cout << print_car(c).type << std::endl;
return 0;
}
class Car {
public:
Car(int i)
:id(i) {
std::cout << "Car("
<< id << ")" << std::endl;
}
~Car() {
std::cout << "~Car("
<< id << ")" << std::endl;
}
int id;
};

Car a(1);
Car b(2);
Car c(3);
return 0;
}
class Car {
public:
Car(int c)
: count(c) {
std::cout << "Car() " << count << std::endl;
}
Car(const Car& c) {
count = count + 1;
std::cout << "Copy Car() " << count << std::endl;
}
~Car() {
std::cout << "~Car() " << count << std::endl;
}
int count;
};

Car c(1);
std::cout << print_car(c).count << std::endl;
return 0;
}
#include <iostream>
class Vehicle {
public:
Vehicle(int tp)
: type(tp) {}
int type;
};
class Car: public Vehicle {

public:
Car(int tp, int model)
: Vehicle(tp) {
std::cout << "Car()" << std::endl;
}
int model;
};

Car c(1,2);
std::cout << c.type << c.model << std::endl;
return 0;
}

#include <iostream>
struct Vehicle {
virtual void honk(){
std::cout << "HONK" << std::endl;
}
};
struct Car: public Vehicle {

std::cout << "...NOT" << std::endl;
}
};

Car c;
c.honk();
return 0;
}
Alocação de Memória
• Java, Python, Perl, Ruby e qualquer outra

linguagem dinâmica esconde isso de você.
• Logo você vai descobrir o motivo.
• É doloroso.
• É perigoso.
• É necessário

new e delete
struct Car {
Car(std::string lvl)
: sound(lvl) {}
std::string honk() { return sound; }
std::string sound;
};

{
Car* car = new Car("HONK!");
std::cout << car->honk() << std::endl;
delete car;
return 0;
}
struct Vehicle {
std::cout << "HONK" << std::endl;
}
};
struct Car: public Vehicle {

std::cout << "...NOT" << std::endl;
}
};
void honk_it(Vehicle* v) {
v->honk();
}

{
Car* car = new Car();
honk_it(car);
delete car;
return 0;
}
Catástrofes de memória

Esse é o motivo de por
que os programas
fecham e exitem falhas
de segurança.

Catástrofes
• Quando você sai de uma função em C++

você perde direito ao que estava no stack
• Todas as outras linguagens usam apenas
memória dinâmica, e usam garbage
collection para deletar o que não é mais
usado

#include <iostream>
struct Car {
std::string sound;
};

{
Car* car = NULL;
return 0;
}

#include <iostream>
struct Car {
std::string sound;
};

{
Car* car;
return 0;
}

#include <iostream>
struct Car {
std::string sound;
};

{
Car* car = (Car*)0xC0DE;
delete car;
std::cout << "No!!" << std::endl;
return 0;
}

#include <iostream>
struct Ninja {
std::string yell() { return level; }
std::string level;
};

{
Ninja* ninja = new Ninja();
ninja->level = "Master";
delete ninja;
std::cout << ninja->yell() << std::endl;
return 0;
}

#include <iostream>
struct Car {
std::string sound;
};
void honk_car() {
Car* car = new Car();
car->sound = "HONK!";
}

honk_car();
std::cout << "Oops" << std::endl;
return 0;
}
Obrigado!
E3C Tecnologia
We’re hiring!

AprendaC Em10Anos

Hochgeladen von

Dokumentinformationen

Originaltitel

Copyright

Verfügbare Formate

Dieses Dokument teilen

Dokument teilen oder einbetten

Freigabeoptionen

Stufen Sie dieses Dokument als nützlich ein?

Sind diese Inhalte unangemessen?

Copyright:

Verfügbare Formate

AprendaC Em10Anos

Hochgeladen von

Copyright:

Verfügbare Formate

Aprenda C++ em 10

quinta-feira, 27 de maio de 2010

quinta-feira, 27 de maio de 2010

quinta-feira, 27 de maio de 2010

quinta-feira, 27 de maio de 2010

Samuel Johnson (1709-1784)

quinta-feira, 27 de maio de 2010

quinta-feira, 27 de maio de 2010

Hippocrates (400 A.C.)

quinta-feira, 27 de maio de 2010

• Vocês já são programadores, mas criados

quinta-feira, 27 de maio de 2010

• Cobrir amplo território

quinta-feira, 27 de maio de 2010

• Toda memória deve ser explicitamente

quinta-feira, 27 de maio de 2010

quinta-feira, 27 de maio de 2010

int main(int argc, char* argv[])

quinta-feira, 27 de maio de 2010

uniqua:~/cpp$ g++ ex1.cpp

quinta-feira, 27 de maio de 2010

• g++ compila o hello.cpp em a.out

quinta-feira, 27 de maio de 2010

int main(int argc, char* argv[])

quinta-feira, 27 de maio de 2010

quinta-feira, 27 de maio de 2010

int main(int argc, char* argv[])

quinta-feira, 27 de maio de 2010

quinta-feira, 27 de maio de 2010

quinta-feira, 27 de maio de 2010

• Strings são seqüencias de caracteres, entre

quinta-feira, 27 de maio de 2010

• Inteiros são int e podem ser unsigned.

quinta-feira, 27 de maio de 2010

quinta-feira, 27 de maio de 2010

int main(int argc, char* argv[])

quinta-feira, 27 de maio de 2010

int main(int argc, char* argv[])

quinta-feira, 27 de maio de 2010

uniqua:~/cpp$ g++ ex3.cpp

ex3.cpp: In function ‘int main(int, char**)’:

quinta-feira, 27 de maio de 2010

int main(int argc, char* argv[])

quinta-feira, 27 de maio de 2010

int main(int argc, char* argv[])

quinta-feira, 27 de maio de 2010

• Podem receber zero ou mais parêmetros

quinta-feira, 27 de maio de 2010

int main(int argc, char* argv[])

quinta-feira, 27 de maio de 2010

int main(int argc, char* argv[])

quinta-feira, 27 de maio de 2010

int main(int argc, char* argv[]) {

int main(int argc, char* argv[]) {

quinta-feira, 27 de maio de 2010

• Endereço de memória, associados a um

quinta-feira, 27 de maio de 2010

• Você pega o endereço de variáveis com &

quinta-feira, 27 de maio de 2010

int main(int argc, char* argv[])

quinta-feira, 27 de maio de 2010

int main(int argc, char* argv[])

quinta-feira, 27 de maio de 2010