[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 pode ser mais difícil ou complexa do que as linguagens mais
recentes, C++ é amplamente utilizado porque compila para instruções nativas que
podem ser executadas diretamente pelo processador e oferece um controlo rígido sobre 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++
//////////////////
// Comparação com C
//////////////////
// C ++ é quase um super conjunto de C e compartilha sua sintaxe básica para
// declarações de variáveis, tipos primitivos, e funções. No entanto, C++ varia
// em algumas das seguintes maneiras:
// A função main() em C++ deve retornar um int, embora void main() é aceita
// pela maioria dos compiladores (gcc, bumbum, etc.)
// Este valor serve como o status de saída do programa.
// Veja http://en.wikipedia.org/wiki/Exit_status para mais informações.
int main(int argc, char** argv)
{
// Argumentos de linha de comando são passados em pelo 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*) representado 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;
}
// Em C++, caracteres literais são um byte.
sizeof('c') == 1
// Em C, caracteres literais são do mesmo tamanho que ints.
sizeof('c') == sizeof(10)
// C++ tem prototipagem estrita
void func(); // função que não aceita argumentos
// Em C
void func(); // função que pode aceitar qualquer número de argumentos
// Use nullptr em vez de NULL em C++
int* ip = nullptr;
// Cabeçalhos padrão C estão disponíveis em C++,
// mas são prefixados com "c" e não têm sufixo .h
#include <cstdio>
int main()
{
printf("Hello, world!\n");
return 0;
}
///////////////////////
// Sobrecarga de função
///////////////////////
// C++ suporta sobrecarga de função
// desde que cada função tenha parâmetros diferentes.
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)
}
/////////////////////////////
// Parâmetros padrão de função
/////////////////////////////
// Você pode fornecer argumentos padrões para uma função se eles não são
// fornecidos pelo chamador.
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
}
// Argumentos padrões devem estar no final da lista de argumentos.
void invalidDeclaration(int a = 1, int b) // Erro!
{
}
/////////////
// Namespaces (nome de espaços)
/////////////
// Namespaces fornecem escopos distintos para variável, função e outras
// declarações. Namespaces podem estar aninhados.
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"
}
///////////////
// Entrada/Saída
///////////////
// C ++ usa a entrada e saída de fluxos (streams)
// cin, cout, and cerr representa stdin, stdout, and stderr.
// <<Éooperadordeinserçãoe>> é o operador de extração.
#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";
}
//////////
// Strings
//////////
// Strings em C++ são objetos e têm muitas funções de membro
#include <string>
using namespace std; // Strings também estão no namespace std (bib. padrão)
string myString = "Hello";
string myOtherString = " World";
// + é usado para concatenação.
cout <<myString+myOtherString;//"HelloWorld"
cout <<myString+"You";//"HelloYou"
// Em C++, strings são mutáveis e têm valores semânticos.
myString.append(" Dog");
cout <<myString;//"HelloDog"
/////////////
// Referência
/////////////
// Além de indicadores como os de C, C++ têm _referências_. Esses são tipos de
// ponteiro que não pode ser reatribuída uma vez definidos e não pode ser nulo.
// Eles também têm a mesma sintaxe que a própria variável: Não * é necessário
// para _dereferencing_ e & (endereço de) não é usado para atribuição.
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"Iamfoo.Hi!"
// Não realocar "fooRef". Este é o mesmo que "foo = bar", e foo == "I am bar"
// depois desta linha.
fooRef = bar;
const string& barRef = bar; // Cria uma referência const para bar.
// Como C, valores const (e ponteiros e referências) não podem ser modificado.
barRef += ". Hi!"; // Erro, referência const não pode ser modificada.
//////////////////////////////////////////
// Classes e programação orientada a objeto
//////////////////////////////////////////
// Primeiro exemplo de classes
#include <iostream>
// Declara a classe.
// As classes são geralmente declarado no cabeçalho arquivos (.h ou .hpp).
class Dog {
// Variáveis de membro e funções são privadas por padrão.
std::string name;
int weight;
// Todos os membros a seguir este são públicos até que "private:" ou
// "protected:" é encontrado.
public:
// 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 objecto 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.
// Funções membro da classe geralmente são implementados em arquivos .cpp.
void Dog::Dog()
{
std::cout << "A dog has been constructed\n";
}
// Objetos (como strings) devem ser passados por referência
// se você está modificando-os ou referência const se você não é.
void Dog::setName(const std::string& dogsName)
{
name = dogsName;
}
void Dog::setWeight(int dogsWeight)
{
weight = dogsWeight;
}
// Observe que "virtual" só é necessária na declaração, não a definição.
void Dog::print() const
{
std::cout << "Dog is " <<name<<"andweighs"<<weight<<"kg\n";
}
void Dog::~Dog()
{
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"
// herança:
// Essa classe herda tudo público e protegido da classe Dog
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.
