---

language: c++

filename: learncpp-pt.cpp

contributors:

- ["Steven Basart", "http://github.com/xksteven"]

- ["Matt Kline", "https://github.com/mrkline"]

translators:

- ["Miguel Araújo", "https://github.com/miguelarauj1o"]

lang: pt-br

---

C++ é uma linguagem de programação de sistemas que,

[de acordo com seu inventor Bjarne Stroustrup](http://channel9.msdn.com/Events/Lang-NEXT/Lang-NEXT-2014/Keynote),

foi concebida para

- ser um "C melhor"

- suportar abstração de dados

- suportar programação orientada a objetos

- suportar programação genérica

Embora sua sintaxe possa ser mais difícil ou complexa do que as linguagens mais

recentes, C++ é amplamente utilizada porque compila para instruções nativas que

podem ser executadas diretamente pelo processador e oferece um controle rígido sobre o hardware (como C), enquanto oferece recursos de alto nível, como os

genéricos, exceções e classes. Esta combinação de velocidade e funcionalidade

faz C++ uma das linguagens de programação mais utilizadas.

```c++

int main(int argc, char** argv)

{

// Argumentos de linha de comando são passados para argc e argv da mesma

// forma que eles estão em C.

// argc indica o número de argumentos,

// e argv é um array de strings, feito C (char*) representando os argumentos

// O primeiro argumento é o nome pelo qual o programa foi chamado.

// argc e argv pode ser omitido se você não se importa com argumentos,

// dando a assinatura da função de int main()

// Uma saída de status de 0 indica sucesso.

return 0;

}

sizeof('c') == 1

sizeof('c') == sizeof(10)

void func(); // função que não aceita argumentos

void func(); // função que pode aceitar qualquer número de argumentos

int* ip = nullptr;

#include <cstdio>

int main()

{

printf("Hello, world!\n");

return 0;

}

void print(char const* myString)

{

printf("String %s\n", myString);

}

void print(int myInt)

{

printf("My int is %d", myInt);

}

int main()

{

print("Hello"); // Funciona para void print(const char*)

print(15); // Funciona para void print(int)

}

void doSomethingWithInts(int a = 1, int b = 4)

{

// Faça alguma coisa com os ints aqui

}

int main()

{

doSomethingWithInts(); // a = 1, b = 4

doSomethingWithInts(20); // a = 20, b = 4

doSomethingWithInts(20, 5); // a = 20, b = 5

}

void invalidDeclaration(int a = 1, int b) // Erro!

{

}

namespace First {

namespace Nested {

void foo()

{

printf("This is First::Nested::foo\n");

}

} // Fim do namespace aninhado

} // Fim do namespace First

namespace Second {

void foo()

{

printf("This is Second::foo\n")

}

}

void foo()

{

printf("This is global foo\n");

}

int main()

{

// Assuma que tudo é do namespace "Second" a menos que especificado de

// outra forma.

using namespace Second;

foo(); // imprime "This is Second::foo"

First::Nested::foo(); // imprime "This is First::Nested::foo"

::foo(); // imprime "This is global foo"

}

#include <iostream> // Inclusão para o I/O streams

using namespace std; // Streams estão no namespace std (biblioteca padrão)

int main()

{

int myInt;

// Imprime na saída padrão (ou terminal/tela)

cout << "Enter your favorite number:\n";

// Pega a entrada

cin >> myInt;

// cout também pode ser formatado

cout << "Your favorite number is " << myInt << "\n";

// imprime "Your favorite number is <myInt>"

cerr << "Usado para mensagens de erro";

}

#include <string>

using namespace std; // Strings também estão no namespace std (bib. padrão)

string myString = "Hello";

string myOtherString = " World";

cout << myString + myOtherString; // "Hello World"

cout << myString + " You"; // "Hello You"

myString.append(" Dog");

cout << myString; // "Hello Dog"

using namespace std;

string foo = "I am foo";

string bar = "I am bar";

string& fooRef = foo; // Isso cria uma referência para foo.

fooRef += ". Hi!"; // Modifica foo através da referência

cout << fooRef; // Imprime "I am foo. Hi!"

fooRef = bar;

const string& barRef = bar; // Cria uma referência const para bar.

barRef += ". Hi!"; // Erro, referência const não pode ser modificada.

#include <iostream>

class Dog {

// Variáveis de membro e funções são privadas por padrão.

std::string name;

int weight;

// Construtor padrão

Dog();

// Declarações de função Membro (implementações a seguir)

// Note que usamos std :: string aqui em vez de colocar

// using namespace std;

// acima.

// Nunca coloque uma declaração "using namespace" em um cabeçalho.

void setName(const std::string& dogsName);

void setWeight(int dogsWeight);

// Funções que não modificam o estado do objeto devem ser marcadas como

// const. Isso permite que você chamá-los se for dada uma referência const

// para o objeto. Além disso, observe as funções devem ser explicitamente

// declarados como _virtual_, a fim de ser substituídas em classes

// derivadas. As funções não são virtuais por padrão por razões de

// performance.

virtual void print() const;

// As funções também podem ser definidas no interior do corpo da classe.

// Funções definidas como tal são automaticamente embutidas.

void bark() const { std::cout << name << " barks!\n" }

// Junto com os construtores, C++ fornece destruidores.

// Estes são chamados quando um objeto é excluído ou fica fora do escopo.

// Isto permite paradigmas poderosos, como RAII

// (veja abaixo)

// Destruidores devem ser virtual para permitir que as classes de ser

// derivada desta.

virtual ~Dog();

}; // Um ponto e vírgula deve seguir a definição de classe.

void Dog::Dog()

{

std::cout << "A dog has been constructed\n";

}

void Dog::setName(const std::string& dogsName)

{

name = dogsName;

}

void Dog::setWeight(int dogsWeight)

{

weight = dogsWeight;

}

void Dog::print() const

{

std::cout << "Dog is " << name << " and weighs " << weight << "kg\n";

}

void Dog::~Dog()

{

std::cout << "Goodbye " << name << "\n";

}

int main() {

Dog myDog; // imprime "A dog has been constructed"

myDog.setName("Barkley");

myDog.setWeight(10);

myDog.printDog(); // imprime "Dog is Barkley and weighs 10 kg"

return 0;

} // imprime "Goodbye Barkley"

class OwnedDog : public Dog {

void setOwner(const std::string& dogsOwner)

// Substituir o comportamento da função de impressão de todas OwnedDogs.

// Ver http://en.wikipedia.org/wiki/Polymorphism_(computer_science)#Subtyping

// Para uma introdução mais geral, se você não estiver familiarizado com o

// polimorfismo subtipo. A palavra-chave override é opcional, mas torna-se

// na verdade você está substituindo o método em uma classe base.

void print() const override;

std::string owner;

};

void OwnedDog::setOwner(const std::string& dogsOwner)

{

owner = dogsOwner;

}

void OwnedDog::print() const

{

Dog::print(); // Chame a função de impressão na classe Dog base de

std::cout << "Dog is owned by " << owner << "\n";

// Prints "Dog is <name> and weights <weight>"

// "Dog is owned by <owner>"

}

#include <iostream>

using namespace std;

class Point {

// Variáveis membro pode ser dado valores padrão desta maneira.

double x = 0;

double y = 0;

// Define um construtor padrão que não faz nada

// mas inicializar o Point para o valor padrão (0, 0)

Point() { };

// A sintaxe a seguir é conhecido como uma lista de inicialização

// e é a maneira correta de inicializar os valores de membro de classe

Point (double a, double b) :

x(a),

y(b)

{ /* Não fazer nada, exceto inicializar os valores */ }

// Sobrecarrega o operador +.

Point operator+(const Point& rhs) const;

// Sobrecarregar o operador +=.

Point& operator+=(const Point& rhs);

// Ele também faria sentido para adicionar os operadores - e -=,

// mas vamos pular para sermos breves.

};

Point Point::operator+(const Point& rhs) const

{

// Criar um novo ponto que é a soma de um e rhs.

return Point(x + rhs.x, y + rhs.y);

}

Point& Point::operator+=(const Point& rhs)

{

x += rhs.x;

y += rhs.y;

return *this;

}

int main () {

Point up (0,1);

Point right (1,0);

// Isto chama que o operador ponto +

// Ressalte-se a chamadas (função)+ com direito como seu parâmetro...

Point result = up + right;

// Imprime "Result is upright (1,1)"

cout << "Result is upright (" << result.x << ',' << result.y << ")\n";

return 0;

}

#include <exception>

try {

// Não aloca exceções no heap usando _new_.

throw std::exception("A problem occurred");

}

catch (const std::exception& ex)

{

std::cout << ex.what();

} catch (...)

{

std::cout << "Exceção desconhecida encontrada";

throw; // Re-lança a exceção

}

void doSomethingWithAFile(const char* filename)

{

// Para começar, assuma que nada pode falhar.

FILE* fh = fopen(filename, "r"); // Abra o arquivo em modo de leitura.

doSomethingWithTheFile(fh);

doSomethingElseWithIt(fh);

fclose(fh); // Feche o arquivo.

}

bool doSomethingWithAFile(const char* filename)

{

FILE* fh = fopen(filename, "r"); // Abra o arquivo em modo de leitura

if (fh == nullptr) // O ponteiro retornado é nulo em caso de falha.

return false; // Relate o fracasso para o chamador.

// Suponha cada função retorne false, se falhar

if (!doSomethingWithTheFile(fh)) {

fclose(fh); // Feche o identificador de arquivo para que ele não vaze.

return false; // Propague o erro.

}

if (!doSomethingElseWithIt(fh)) {

fclose(fh); // Feche o identificador de arquivo para que ele não vaze.

return false; // Propague o erro.

}

fclose(fh); // Feche o identificador de arquivo para que ele não vaze.

return true; // Indica sucesso

}

bool doSomethingWithAFile(const char* filename)

{

FILE* fh = fopen(filename, "r");

if (fh == nullptr)

return false;

if (!doSomethingWithTheFile(fh))

goto failure;

if (!doSomethingElseWithIt(fh))

goto failure;

fclose(fh); // Close the file

return true; // Indica sucesso

failure:

fclose(fh);

return false; // Propague o erro.

}

void doSomethingWithAFile(const char* filename)

{

FILE* fh = fopen(filename, "r"); // Abra o arquivo em modo de leitura.

if (fh == nullptr)

throw std::exception("Não pode abrir o arquivo.");

try {

doSomethingWithTheFile(fh);

doSomethingElseWithIt(fh);

}

catch (...) {

fclose(fh); // Certifique-se de fechar o arquivo se ocorrer um erro.

throw; // Em seguida, re-lance a exceção.

}

fclose(fh); // Feche o arquivo

// Tudo ocorreu com sucesso!

}

void doSomethingWithAFile(const std::string& filename)

{

// ifstream é curto para o fluxo de arquivo de entrada

std::ifstream fh(filename); // Abra o arquivo

// faça alguma coisa com o arquivo

doSomethingWithTheFile(fh);

doSomethingElseWithIt(fh);

} // O arquivo é automaticamente fechado aqui pelo destructor

template<class T>

T soma(T a, T b) {

return A + B;

}

int i=5, j=6, k;

double f=2.0, g=0.5, h;

k=sum<int>(i,j);

h=sum<double>(f,g);

```

Leitura Adicional:

* Uma referência atualizada da linguagem pode ser encontrada em [CPP Reference](http://cppreference.com/w/cpp).

* Uma fonte adicional pode ser encontrada em [CPlusPlus](http://cplusplus.com).

* Um tutorial cobrindo o básico da linguagem e configurando o ambiente de codificação está disponível em [TheChernoProject - C ++](https://www.youtube.com/playlist?list=PLlrATfBNZ98dudnM48yfGUldqGD0S4FFb).