C++

C++
Paradigma	programação genérica orientação a objeto programação procedural abstração de dados
Surgido em	1985, última revisão em 2003
Criado por	Bjarne Stroustrup
Estilo de tipagem	estática, fraca ou forte, insegura
Principais implementações	GNU Compiler Collection, Microsoft Visual C++, Borland C++ Builder
Dialetos:	ANSI C++ 1998, ANSI C++ 2003
Influenciada por	C, Simula, Ada 83, CLU
Influenciou	Ada 95, C#, Java, D, PHP

O C++ (em português lê-se "cê mais mais" ou /sê/ /máys/ /máys/, em inglês lê-se "cee plus plus" ou /si/ /plâs/ /plâs/) é uma linguagem de programação de alto nível com facilidades para o uso em baixo nível, multiparadigma e de uso geral. Desde os anos 1990 é uma das linguagens comerciais mais populares.

Bjarne Stroustrup desenvolveu o C++ (originalmente com o nome C with Classes, que significa C com classes em inglês) em 1983 no Bell Labs como um adicional à linguagem C. Novas características foram adicionadas com o tempo, como classes, funções virtuais, sobrecarga de operadores, herança múltipla, templates e tratamento de exceções. Uma nova versão do padrão da linguagem está em desenvolvimento, conhecida informalmente como C++0x.

História

A evolução da linguagem

O C++ foi inicialmente desenvolvido por Bjarne Stroustrup dos Bell Labs durante a década de 1980 com o objectivo de melhorar a linguagem de programação C, sendo que um de seus objetivos era manter compatibilidade com aquela linguagem. Stroustrup percebeu que a linguagem Simula possuía características bastante úteis para o desenvolvimento de software, mas era muito lenta para uso prático. Por outro lado o BCPL era rápido, mas possuía baixo nível, dificultando sua utilização em desenvolvimento de aplicações. Durante seu período na Bell Labs, ele enfrentou o problema de analisar o kernel UNIX com respeito à computação distribuída. A partir de sua experiência de doutorado, começou a acrescentar elementos do Simula no C. C foi escolhido pois possuía uma proposta de uso genérico, era rápido e também portável para diversas plataformas. Algumas outras linguagens que também serviram de inspiração para o informático foram ALGOL 68, Ada, CLU e ML. A primeira versão comercial foi lançada em outubro de 1985 .

Bjarne Stroustrup, idealizador da linguagem C++

Ainda em 1983 o nome da linguagem foi alterado de C with Classes para C++. Novas características foram adicionadas, como funções virtuais, sobrecarga de operadores e funções, referências, constantes, controle de memória pelo usuário, melhorias na checagem de tipo e estilo de comentário de uma linha (//). Em 1985 foi lançada a primeira edição do livro The C++ Programming Language, contendo referências para a utilização da linguagem, já que ainda não era uma norma oficial. Em 1989 a segunda versão do C++ foi lançada, contendo novas características como herança múltipla, classes abstratas, métodos estáticos, métodos constantes e membros protegidos. Em 1990 foi lançado o livro The Annotated C++ Reference Manual, que tornou-se base para o futuro padrão. Outras adições na linguagem incluem templates, exceções, espaço de nomes, mudança de tipo segura e o tipo bool.

Assim como a linguagem, sua biblioteca padrão também sofreu melhorias ao longo do tempo. Sua primeira adição foi a biblioteca de I/O, e posteriormente o Standard Template Library. Esses dois novos elementos foram um dos principais meios para que o C++ se distanciasse cada vez mais do C.

Depois de anos de trabalho, um comitê unificado ANSI e ISO padronizou o C++ em 1998 (ISO/IEC 14882:1998). Após alguns anos foram reportados alguns defeitos no padrão, e uma correção foi lançada em 2003.

Por muito tempo foi encarada muitas vezes como um superconjunto do C, entretanto em 1999 o novo padrão ISO para a linguagem C, conhecido como C99, tornou as duas linguagens diferentes entre si. Por causa destas incompatibilidades, muitas empresas que desenvolvem compiladores não oferecem suporte à versão mais recente da linguagem C.

Pode-se dizer que C++ foi a única linguagem entre tantas outras que obteve sucesso como uma sucessora à linguagem C, inclusive servindo de inspiração para outras linguagens como Java, a IDL de CORBA e C#.

O nome C++

O termo C++ é creditado a Rick Mascitti, e foi utilizado pela primeira vez em dezembro de 1983. Durante sua fase inicial de desenvolvimento, a linguagem era chamada novo C ou ainda C com classes. O nome C++ é referência ao operador de incremento ++, significando um acréscimo (uma evolução) da linguagem C. Em tom humorado, desenvolvedores de programa de computador e especialistas em informática no início da década de 1990 costumavam relacionar o ++ do nome à grande insistência dos programadores em utilizar o C++ da mesma forma que a linguagem C, não usufruindo das novas facilidades que a linguagem poderia fornecer. Assim como o ++ estava sendo aplicado de maneira pós-fixa à letra C, a linguagem C++ era uma evolução do C pós-fixada, que só tornar-se-ia realidade em algum futuro remoto, não naquele momento.

Trabalhos futuros

O C++ continua evoluindo de forma a possuir novos requisitos. Um grupo em particular, o Boost.org, trabalha para evoluir a biblioteca padrão, avisando ao comitê oficial da linguagem quais facilidades possuem maior retorno positivo dos usuários, seja por qualidade ou utilidade; e quais ainda devem ser desenvolvidas. Tudo indica que o C++ continuará com sua natureza multiparadigma como nunca. O trabalho da Boost.org, por exemplo, dedica-se muito em acrescentar as qualidades da programação funcional e genérica. O C++ padrão não define implementação para definição de normas, tratamento de exceções, entre outras facilidades específicas, o que freqüentemente torna incompatíveis códigos objeto produzidos por diferentes compiladores. Apesar disso, existem padrões periféricos específicos para certas plataformas ou sistemas operacionais para padronizar compiladores dessas plataformas, como por exemplo o C++ ABI.

Compiladores C++ ainda se esforçam para suportar inteiramente o padrão, especialmente na área de templates. Uma das disputas se refere à palavra reservada export, que permite que definições de template sejam separadas de suas declarações. O primeiro compilador a implementar export foi o Comeau C++, em 2003 (cinco anos após o lançamento do padrão). Em 2004, uma versão beta do compilador Borland C++ Builder X também suportava a facilidade. Ambos os compiladores são baseados na versão EDG do C++. Muitos livros fornecem exemplos de códigos para implementar export que não é compilável, mas não há referências para o problema mencionado. Outros compiladores como o Microsoft Visual C++ e o GCC não suportam a facilidade. Herb Sutter, secretário do comitê oficial do C++, recomendou que a palavra fosse removida de versões futuras do padrão C++, mas a decisão final foi mantê-la no padrão .

Outras disputas relativas a templates se referem à especialização parcial, que foi pouco suportada por muitos anos depois que o C++ padrão foi lançado.

Atualmente o comitê de padronização do C++ está trabalhando para estender a linguagem em uma nova especificação, conhecida informalmente por C++0x. Esse nome é uma referência ao ano no qual o padrão será lançado, possivelmente em 2009. A maioria do trabalho foca em grandes adições na biblioteca padrão e muito poucas na especificação da própria linguagem. Grande parte das inovações será derivada do trabalho desenvolvido pelo grupo Boost, que já provou o conceito de várias inovações em uma ampla base de usuários. Novas funcionalidades previstas para a biblioteca padrão incluem suporte à expressões regulares, suporte à tuplas, dedução de tipo de dado através da palavra reservada auto, suporte ao cálculo lambda, delegação de construtores e adição da palavra reservada finally para tratamento de exceções, entre outras.

Características

Filosofia

No livro In The Design and Evolution of C++ (1994), Bjarne Stroustrup descreve algumas regras que ele utiliza para desenvolver o C++, como exemplificado abaixo:

• C++ é desenvolvido para ser uma linguagem tipada estaticamente e de proposta geral que é tão eficiente e portável quanto o C.
• C++ é desenvolvido para suportar múltiplos paradigmas.
• C++ é desenvolvido para fornecer ao programador escolhas, mesmo que seja possível ao programador escolher a opção errada.
• C++ é desenvolvido para ser o quanto mais compatível com C possível, fornecendo transições simples para código C.
• C++ evita fornecer facilidades que são específicas a certas plataformas ou a certos grupos de desenvolvedores.
• C++ não exige overhead para facilidades que não são utilizadas.
• C++ é desenvolvido para ser utilizado mesmo sem um ambiente de desenvolvimento sofisticado.

Stanley B. Lippman documenta em seu livro Inside the C++ Object Model (1996) como compiladores convertem código de programas C++ em mapeamentos de memória. Lippman trabalhou implementando e mantendo o C-front, a implementação original do C++ nos Bell Labs.

Stroustrup sempre desejou que o C++ fosse mantido como uma linguagem de pequena especificação, apesar de pressões externas para adições de novas funcionalidades na especificação da própria linguagem ao invés da codificação de novas bibliotecas para a biblioteca padrão. Brian Kernighan notou que enquanto em C existe geralmente uma maneira de resolver problemas, no C++ existem várias. Na maioria das linguagens de programação um padrão ou um conjunto bastante restrito de padrões de codificação é escolhido para o desenvolvimento, algo que não acontece no C++, pois a escolha é delegada ao desenvolvedor. É um conceito que prega que não existe paradigma de linguagem ou padrão de codificação que resolva todos os problemas, por isso a pluralidade e generalidade de aplicações para a linguagem. Tal filosofia assusta iniciantes e professores, que sentem que a linguagem deveria ser de fácil aprendizado, algo que o C++ não é.

Biblioteca padrão

Artigo principal: Biblioteca padrão do C++

A biblioteca padrão do C++ incorpora a biblioteca padrão do C com algumas pequenas modificações para trabalhar melhor com as novas funcionalidades criadas pela linguagem. Outra grande parte da biblioteca é composta pela biblioteca padrão de templates (STL). Ela fornece ferramentas úteis como containers (vetores, listas, entre outros) e iteradores (ponteiros genéricos para acessar tais containers). Usando templates é possível escrever algoritmos genéricos que funcionam para qualquer container ou sequência definida por iteradores. Como em C, as facilidades da biblioteca são acessadas utilizando a diretiva #include para incluir as bibliotecas padrão. São fornecidos 69 cabeçalhos-padrão, dos quais 19 estão em depreciação.

Devido ao fato da biblioteca padrão ter sido desenvolvida por especialistas e de já ter sido amplamente utilizada comercialmente, é recomendado utilizar seus componentes ao invés de componentes próprios. Por exemplo, utilizar std::vector e std::string ao invés de declarar vetores herdados do C não somente tornará o desenvolvimento mais simples, como também trará mais segurança e escalabilidade para seu sistema.

A STL era originalmente uma biblioteca da HP e depois da SGI, antes de sua incorporação na biblioteca padrão do C++. O padrão não a define como "STL", já que ela representa somente parte da biblioteca padrão, mas muitas pessoas ainda usam esse termo para distingui-la do resto da biblioteca. O projeto STLPort, baseado na SGI STL, mantém uma implementação atualizada da biblioteca. O projeto Boost fornece elementos adicionais à STL, alguns dos quais já são considerados a serem parte da biblioteca padrão no futuro.

Operadores

Ver artigo principal: Operadores em C e C++

Os operadores em C++ são um conjunto de todos os operadores do C mais novas adições à linguagem. Um grupo de novos operadores do C++ são os relativos à conversão de tipo de dado, e consistem em const_cast, static_cast, dynamic_cast e reinterpret_cast. É uma evolução a conversão de dados utilizada em C, que limitava-se a oferecer um método para conversão tal qual static_cast. dynamic_cast refere-se diretamente ao suporte de herança e polimorfismo oferecido pela linguagem, e está relacionado com o outro novo operador typeid, que retorna informações sobre o tipo derivado pelo operando. Ambos os operadores requerem a habilitação de RTTI. Outro grupo de novos operadores são os relativos à alocação de memória, e consistem em new e delete, assemelhando-se às funções malloc e free respectivamente, presentes na biblioteca padrão do C. Outro novo operador é o de resolução de escopo, ::, e que refere-se diretamente ao suporte de espaços de nome e objeto oferecido pela linguagem.

O C++ permite que os alguns dos operadores sejam sobrecarregados, que assim como a sobrecarga de funções, permite que diferentes tipos de dado sejam passados para um operador de forma a produzir diferentes resultados. Essa técnica também permite que classes definidas por usuários também possam usufruir de operadores próprios, tornando possível que uma classe Lista possa sobrecarregar o operador de apêndice += para que diversos elementos possam ser adicionados a lista, como elementos ou outras listas. Alguns operadores de classes definidas pelo usuário devem obrigatoriamente ser sobrecarregados (criados), a fim de poderem ser utilizados pela STL. Por exemplo, uma classe Funcionario deve fornecer o operador menor que (<) para ser utilizada pela função de ordenação (sort).

Pré-processador

O C++ é compilado em três fases: pré-processamento, tradução para código objeto e ligação . Durante a primeira fase as diretivas de pré-processamento, identificadas no código fonte através de # são aplicadas com transformações léxicas no próprio código fonte, que então alimenta as próximas fases de compilação. Por exemplo, o código:

#define PI 3.1415926535897932384626433

fará com que sempre que PI aparecer no código, este será substituido por 3.1415926535897932384626433. Da mesma maneira:

#include <iostream>

fará com que seja incluido (importado) todos os símbolos da biblioteca iostream.

Templates

Templates são diferentes de macros: enquanto ambas as facilidades podem ser utilizadas para produzir código em tempo de compilação, templates não restringem-se à substituições léxicas. Possuem conhecimento da semântica e do sistema de tipagem da linguagem. São utilizados principalmente para polimorfismo estático (ver exemplo abaixo) e programação genérica. Um template também é uma máquina de Turing completa.

No campo de programação genérica, um tipo de dado parametrizado em C++ é chamado uma classe template. Ela define através de parâmetros como devem ser os tipos de dado internos utilizados ao instanciar o objeto. Dessa maneira é possível codificar uma classe genérica arranjo, que ao ser instanciada pode tornar-se um arranjo de números inteiros ou um arranjo de carros de corrida (desde que carro de corrida esteja definido no escopo da instância).

Objetos

Ver artigo principal: Orientação a objeto

O C++ introduziu alguns conceitos da orientação a objeto ao C, como exemplificado pelas classes, que apresentam quatro características comumente presentes em linguagens de programação orientadas a objeto: abstração, encapsulamento, herança e polimorfismo. Cada vez que uma classe é instanciada é criado um objeto na memória, que é basicamente um conjunto de atributos e operações reunidos.

Encapsulamento

Ver artigo principal: Encapsulamento

O encapsulamento permite que atributos de classes possam ser declarados como públicos, privados ou protegidos. Um atributo público pode ser acessado a partir de qualquer outra função. Um atributo privado só pode ser acessado de funções membro da própria classe e de funções explicitamente declaradas como permitidas para tal (funções friend). Atributos protegidos só podem ser acessados de funções da mesma classe, de funções de classes herdadas e de funções explicitamente declaradas (utilizando a palavra reservada friend). É considerado como uma boa prática de programação tornar todos os dados privados ou protegidos, e tornar públicas somente as funções que realizam uma interface mínima para com a classe, de forma a isolar detalhes de implementação.

O isolamento dos dados proposto pelo encapsulamento não é infalível, podendo ser contornado ao realizar operações de baixo nível em objetos. Dessa maneira, um atributo privado pode ser acessado e modificado a partir de um ponteiro para seu endereço de memória sem problemas, ainda que isso seja considerado uma má prática de programação. Tal característica, herdada da linguagem C, é reflexo direto da liberdade que o C++ fornece ao desenvolvedor em relação a padrões de codificação, cabendo a ele decidir qual é a mais adequada para seu algoritmo. O desenvolvedor tanto pode esquecer tal característica, atendo-se somente a detalhes de especificação em alto nível, quanto adequar tais características em sua especificação de forma mais baixo nível, visando desempenho ou algum outro objetivo.

Herança

Ver artigo principal: Herança

Herança de uma classe para com outra pode ser declarada como pública, protegida ou privada. Isso determina o quão relacionadas as classes serão entre si. Somente a herança pública corresponde ao conceito usual de herança, pois permite acesso total aos atributos da classe-base. A herança adicionou ao C++ a possibilidade de criação de classes abstratas, que não podem ser instanciadas, mas oferecem interfaces de funcionamento para suas respectivas classes herdadas. A herança é um princípio básico da orientação a objeto para a reutilização de código, pois permite que classes (possivelmente escritas por outros desenvolvedores e então não modificáveis) possam ser herdadas de forma a ser incrementadas em funcionalidade.

Herança múltipla é uma das características do C++ mais controversas. Permite que uma classe possa ser derivada de mais de uma classe base, o que pode resultar em um complicado grafo de herança e relacionamento entre classes. Por exemplo, uma classe Gato voador pode ser derivada tanto das classes Gato quanto Mamífero voador. A mistura de heranças reflete em uma mistura de espaços de nomes na classe herdada, o que pode ser resolvido através da declaração local de espaço de nomes, como explicado adiante.

Polimorfismo

Ver artigo principal: Polimorfismo

C++ suporta diversos tipos de polimorfismos, sejam estáticos (resolvidos em tempo de compilação de código) ou dinâmicos (resolvidos em tempo de execução de código). A sobrecarga de funções é um polimorfismo estático que permite que um programa possa declarar várias funções com o mesmo nome, diferenciando entre si pela quantidade e tipo de dado de seus parâmetros. Sobrecarga de operadores também é um polimorfismo estático que permite que programas definam certos operadores resultem em uma chamada de função que depende dos tipos de dado dos operadores sendo utilizados. Polimorfismo por herança é um exemplo de polimorfismo dinâmico no qual ponteiros de uma classe base podem referenciar objetos de classes derivadas, o que permite que uma chamada de função virtual seja resolvida em tempo de execução de código.

Ponteiros e referências de uma classe base podem referenciar objetos de qualquer classe derivada de si, o que permite que arranjos e outros containers de um dado tipo possam armazenar ponteiros de diversos tipos de dados, o que não poderia ser feito de outra maneira em C++. Como não é possível descobrir se tal conversão é segura em tempo de compilação, a checagem deve ser feita durante a execução do código. Para isso é fornecido o operador dynamic_cast, que permite tentar a conversão segura de uma classe mais abstrata (classe base) para outra mais específica (classe derivada). Para sua utilização a linguagem dispõe do RTTI, uma técnica para manter em memória informações sobre o tipo de dado de objetos. Caso a conversão não seja possível uma exceção específica é lançada.

Tratamento de exceções

O tratamento de exceção é um mecanismo desenvolvido para lidar com a ocorrência de algumas condições (chamadas exceções) que alteram o funcionamento normal do fluxo de um programa. O C++ suporta tal tratamento, de forma que o estado atual de um programa após uma exceção é alterado automaticamente para outro estado pré-definido para a recuperação do sistema.

Para isso foram adicionadas à linguagem as palavras reservadas try e catch. A primeira especifica um bloco de código que será vigiado em relação à exceções, de forma que se uma for identificada, o fluxo de programa será desviado para um bloco especificado pela segunda palavra reservada. Para um dado bloco try podem existir diversos blocos catch, capturando exceções de diferentes tipos de dado. Alternativamente, a sintaxe catch(...) foi introduzida para especificar um bloco de tratamento de exceção independente do tipo da exceção, genérico.

O conceito puro da Ciência da Computação para tratamento de exceções ainda inclui o bloco de instruções finally, que indica um conjunto de instruções executadas após um bloco try caso nenhuma exceção tenha sido lançada, indicando sucesso na operação. Tal abordagem não foi adicionada ao C++, sendo substituível por outras técnicas como RAII. De qualquer forma, é possível que essa funcionalidade seja adicionada na próxima especificação da linguagem.

Espaço de nomes

O C++ introduziu espaços de nomes para a organização das bibliotecas. Um espaço de nomes agrupa um contexto para identificadores (variáveis, funções, classes, estruturas, entre outros). No contexto de sistemas operativos, o espaço de nomes poderia ser representado por diretórios. Toda a biblioteca padrão está contida no espaço de nomes std (abreviação de standard, que significa padrão em inglês). Para utilizar um espaço de nomes pode ser feita tanto uma declaração global dos espaços quanto local. Uma declaração global é normalmente inserida no início dos módulos, após a importação dos módulos externos, utilizando a palavra reservada using (como em using namespace std;, ver exemplo contextualizado abaixo). Uma declaração local é inserida antes de invocar o identificador envolvido, utilizando o operador de resolução de escopo :: (como em std::cout, ver exemplo contextualizado abaixo). A declaração global é útil para reduzir a quantidade de código produzido, sub entendendo a origem dos identificadores utilizados. Apesar disso deixa margem à ambiguidades, pois é possível que um mesmo identificador esteja presente em mais de um espaço de nome importado no módulo. Para eliminar esse problema deve-se, além de utilizar a declaração global, declarar o identificador ambíguo localmente cada vez que for utilizado.

Em determinadas ocasiões, espaços de nome não considerados durante a primeira verificação do espaço de nomes de uma função podem também ser utilizados na busca, dependendo dos tipos de dados utilizados nos argumentos. A técnica, chamada busca de nomes dependente de argumento ou Koening lookup, ocorre quando a busca explícita pela função não encontra correspondente, começando então a procurar por espaços de nomes associados. Um padrão muito utilizado pela Standard Template Library é declarar sobrecarga de operadores que somente são encontrados pelo compilador através da técnica.

Incompatibilidade com C

C++ foi considerada no passado um super conjunto de C, o que foi sendo criticado com o tempo. A maioria dos códigos C podem ser compilados em C++ sem problemas, mas existem algumas pequenas diferenças entre as liguagens que tornam alguns códigos C válidos em códigos C++ inválidos.

Talvez a diferença mais comum é que C permite a implícita conversão entre o tipo de dado void* para ponteiros para outros tipos, algo que o C++ não permite. Logo, o seguinte código em C é válido:

int *i = malloc(sizeof(int) * 5);     /* conversão implícita de void* para int* */

Para assegurar-se que o código funcione tanto em C quanto C++ é necessário explicitar a conversão:

int *i = (int *) malloc(sizeof(int) * 5); /* conversão explícita de void* para int* */

Outra questão de portabilidade entre as linguagens é o fato do C++ adicionar várias novas palavras reservadas, como new e class, que podem ser utilizadas como identificadores (por exemplo nomes de variáveis) em C, gerando incompatibilidade.

Algumas outras incompatibilidades foram removidas no padrão C99, que agora suporta facilidades como comentários por //. Tanto o C99 quanto o C++ definem o tipo de dado bool e suas respectivas constantes true e false. Apesar disso, enquanto a definição no C++ é embutida na própria linguagem, tornando tais elementos palavras reservadas, em C tais identificadores são declarados através da biblioteca padrão stdbool.h.

Algumas construções sintáticas são válidas tanto em C quanto C++, mas produzem resultado diferente. Por exemplo, o valor literal 'a' possui tipo de dado int em C e char em C++, o que significa que uma chamada sizeof('a'), que retorna a quantidade de bytes ocupada pelo identificador, possui resultados diferentes entre as duas linguagens.

Exemplos de código

Programa mínimo

Este é um exemplo de um programa mínimo que faz nada. Ele começa sua execução e logo termina. A função main é definida como o ponto de início de um programa.

Notas com questões de compilador

Ainda que o padrão C++ não exija return 0; na função main, alguns compiladores antigos como o Microsoft Visual C++ 6 retornam avisos ou erros com tal situação e podem não gerar código objeto correto.

int main()
{
}

O padrão C++ exige que main() retorne o tipo de dado int. Tradicionalmente, o valor do retorno representa o valor de retorno do próprio programa, o qual é informado para o processo que o executou. Um término mal sucedido pode ser indicado com um valor diferente de zero. O valor assumido por padrão é zero, que representa retorno bem sucedido.

Olá mundo

Este é um exemplo do Programa Olá Mundo aplicado à linguagem C++ que utiliza a biblioteca padrão para a entrada e saída de dados.

Notas com questões de compilador

A adição da biblioteca padrão <ostream> pode ser necessária para alguns compiladores. Isto deve-se ao fato do padrão ISO C++ exigir que a biblioteca padrão <iostream> declare o objeto std::cout como uma instância de da classe std::ostream, mas não obriga que <iostream> defina a classe std::ostream e seus operadores.

#include <iostream> // Necessário para std::cout e std::endl

int main()
{  
   std::cout << "Ola Mundo!" << std::endl;
   return 0;  
}

Nota-se no exemplo acima a declaração local de quais espaços de nome estão sendo utilizados.

Templates

Este é um exemplo da utilização de templates para a substituição da seguinte macro comumente utilizada em C, apesar de bastante perigosa, para o retorno do maior entre dois elementos dados:

// versão utilizando macros

#define max( x, y ) ( x > y ? (x) : (y) )

// versão utilizando templates, muito mais segura e com checagem de tipo

template <typename T>
T max(T x, T y)
{
    return (x > y) ? x : y;
}

Polimorfismo estático

Este é um exemplo de polimorfismo resolvido em tempo de compilação de código, representando a sobrecarga de funções.

extern void EnviaTrabalhoParaImpressora( TrabalhoTexto *, ImpressoraLaser * );
extern void EnviaTrabalhoParaImpressora( TrabalhoTexto *, ImpressoraTinta * );
extern void EnviaTrabalhoParaImpressora( TrabalhoHTML *, ImpressoraLaser * );
extern void EnviaTrabalhoParaImpressora( TrabalhoHTML *, ImpressoraTinta * );

Polimorfismo dinâmico

Este é um exemplo de polimorfismo resolvido em tempo de execução de código, representando funções virtuais.

#include <iostream>

class Passaro                 // classe base
{
public:
  virtual void MostraNome()
  {
    std::cout << "um passaro";
  }
  virtual ~Passaro() {}
};

class Cisne: public Passaro   // Cisne é um pássaro
{ 
public:
  void MostraNome()
  {
    std::cout << "um cisne";  // sobrecarrega a função virtual
  }
};

int main()
{
  Passaro* passaro = new Cisne;

  passaro->MostraNome();    // produz na saída "um cisne", e não "um pássaro"

  delete passaro;

  return 0;
}

Utilizando a bilioteca padrão

Este é um exemplo de programa que utiliza elementos da Standard Template Library.

#include <iostream>   // std::cout
#include <vector>     // std::vector<>
#include <map>        // std::map<> and std::pair<>
#include <algorithm>  // std::for_each()
#include <string>     // std::string

using namespace std;  // importa o espaço de nomes "std" ao espaço de nomes global

void mostra_quantidade_de_itens(pair< string const, vector<string> > const& pessoa)
{
   // "pessoa" é um par de objetos: pessoa.first é o nome da pessoa,
   // pessoa.second é uma lista dos itens da pessoa (arranjo de strings)
   cout << pessoa.first << " esta carregando " << pessoa.second.size() << " itens\n";
}

int main()
{
   // Declara um mapeamento com chaves de strings e arranjos de strings como dado
   map< string, vector<string> > itens;

   // Adiciona algumas pessoas no mapeamento e permite que elas carreguem alguns itens
   items["Anya"].push_back("livro");
   items["Dimitri"].push_back("computador pessoal");
   items["Anya"].push_back("casaco");

   // Percorre por todos os itens do container
   for_each(items.begin(), items.end(), mostra_quantidade_de_itens);
   return 0;
}

Nota-se no exemplo acima a declaração global de quais espaços de nome estão sendo utilizados.

Busca de nomes dependente de argumento

O exemplo clássico de busca de nomes dependente de argumento, também chamada Koenig lookup, é mostrado abaixo:

namespace NS
{
   class A {};
   void f( A ) {}
}

int main()
{
   NS::A a;
   f( a );     // invoca NS::f
}

Note que não foi necessário especificar o espaço de nomes da função f, ainda que ela foi encontrada devido à sua associação com a classe A utilizada como argumento.

Tratamento de exceções

Abaixo é mostrado um exemplo do tratamento de exceções presente no C++. A divisão de um número por zero não é autorizada por processadores, logo a função seguinte divisao_por_dez, que possui uma variável como divisor, deve primeiramente tratar casos inválidos de entrada. Caso a estrada seja zero, uma exceção será lançada, e o código será redirecionado para o tratamento da exceção (indicado por catch).

#include <iostream>

using namespace std;

int divisao_de_dez_por( int divisor )
{
   // prevendo entrada inválida
   if( divisor == 0 )
   { 
      throw "divisão por zero";
   }

   return 10 / divisor;
}

int main()
{
   int div, resultado;

   cin >> div; // obtém do usuário um número inteiro

   try
   {
      resultado = divisao_de_dez_por( div );
   }
   catch( const char *e )
   { // código será redirecionado para cá caso ( div == 0 )
      resultado = 0; // recuperação do sistema
      cout << "Houve uma exceção: " << e << endl;
   }

   return 0;
}

Críticas

“ C faz com que dar um tiro no pé seja fácil; C++ torna isso mais difícil, mas quando nós o fazemos rebenta com a perna toda. ”

A citação de Stroutrup trata com humor o fato de o C++, ao possibilitar a programação de alto nível, ter facilitado a codificação de algoritmos e organização de projetos em relação ao C, uma linguagem que requer constante atenção contra erros lógicos de programação devido à sua alta flexibidade. Por lado, o C++ possui nuances da sintaxe e semântica da linguagem muito sutis, difíceis de serem identificados, e que quando não percebidos podem levar a comportamentos indesejados no código.

Vantagens

• Produção de código o quanto mais eficiente possível
• Possibilidade em programação de alto e baixo nível
• Alta flexibilidade, portabilidade e consistência
• Adequado para grandes projetos
• Ampla disponibilidade e suporte, devido principalmente à grande base de desenvolvedores
• Não está sob o domínio de uma empresa (em contraste do Java - Sun ou Visual Basic - Microsoft). Padronização pela ISO
• Grandes possibilidades para a metaprogramação e programação genérica
• Compatilidade com C, resultando em vasta base de códigos

Desvantagens

• Compatilidade com o C herdou os problemas de entendimento de sintaxe do mesmo
• Os compiladores atuais nem sempre produzem o código mais otimizado, tanto em velocidade quando tamanho do código
• Grande período para o aprendizado
• A biblioteca padrão ainda não cobre áreas importantes da programação, como threads, conexões TCP/IP e manipulação de sistemas de arquivos, o que implica na necessidade de criação de bibliotecas próprias para tal, que pecam em portabilidade
• Devido à grande flexibilidade no desenvolvimento, é recomendado o uso de padrões de programação mais amplamente que em outras linguagens

Ferramentas

Compiladores

Abaixo é mostrada uma lista dos principais compiladores C++.

Compilador	Comentário	É software livre?	Apresenta IDE?	Plataforma
G++	Um componente do GCC	Sim	Não	Unix, Linux, Mac OS X, Windows e AmigaOS
Intel C++	Produz código otimizado para processadores Intel	Não	Não	Windows e Linux
Microsoft Visual C++	É o mais conhecido para a plataforma Windows. Oferece ainda uma versão gratuita com restrições de uso	Não	Sim	Windows
C++ Builder	Oferece versões antigas gratuitas sem presença de IDE.	Não	Sim	Windows e Linux
Open Watcom	Suporta plataformas antigas, até então sem suporte completo à biblioteca padrão	Sim	Sim	DOS, Windows, OS/2 e Netware
Comeau C++	Pode ser experimentado pela Internet	Não	Não	Windows, Linux e Solaris
Turbo C++	Possui versão gratuita no sítio oficial e também uma versão paga. É similar ao C++ Builder.	Não	Sim	Windows

Aplicativos desenvolvidos em C++

Abaixo segue uma lista de aplicativos parcial ou totalmente escritos em C++.

• Adobe Acrobat
• Adobe Photoshop
• Amazon
• BeOS
• Blender
• Common Desktop Environment
• Doom III (motor do jogo)
• eMule
• Motores Google, em especial Googlebot
• Série Half-Life
• Illustrator
• Internet Explorer
• IPod (GUI)
• KDE

• MAC OS X
• Maya
• Mars Pathfinder, Opportunity e outras sondas da NASA
• Microsoft Office
• Mozilla Firefox
• Mozilla Thunderbird
• MySQL
• OpenOffice e BrOffice
• Outlook Express
• SETI@home
• Symbian OS
• Visual Studio (Visual Basic, Visual FoxPro, Visual C++)
• Winamp
• Windows (diversas versões)

Notas e referências

• Bjarne Stroustrup (1994). The Design and Evolution of C++. [S.l.]: Addison-Wesley. ISBN 0-201-54330-3 
• Andrei Alexandrescu e Herb Sutter (2004). C++ Design and Coding Standards: Rules and Guidelines for Writing Programs. [S.l.]: Addison-Wesley. ISBN 0-321-11358-6 

Ver também

Referências à própria linguagem

• Biblioteca padrão do C++
• Biblioteca Boost
• Operadores em C e C++
• Standard Template Library

Linguagens de programação relacionadas

• C
• Simula
• C#
• Cω
• D
• Java

Ligações externas

Grupos de discussão e de suporte

• (em português) Grupo de usuários C/C++ Brasil
• (em inglês) Fórum C++

Material de estudo

• (em inglês) Página oficial do comitê C++ - JTC1/SC22/WG21
• (em inglês) Tutorial C++
• (em inglês) Happy Codings - algoritmos em C++
• (em inglês) Comparativo entre compiladores
• (em inglês) Relação completa e detalhada das incompatibilidades entre C e C++

Bibliotecas e repositórios de código

• (em inglês) Boost.org - conjunto de bibliotecas C++ revisadas por especialistas, desenvolvidas para serem utilizadas em conjunto com a biblioteca padrão
• (em inglês) csourcesearch.net - repositório de código livre C e C++
• (em inglês) CommonCPP - classes fundamentais portáveis da GNU
• (em inglês) STLSoft - bibliotecas livres, compostas somente de cabeçalhos, com o intuito de servir como extensão à STL
• (em inglês) C/C++ Reference - referências de C/C++