C++ using e typedef

Alguns tipos do C++ têm nomes enormes: std::map<std::string, std::string>, std::vector<Aluno>. Outros têm nomes curtos demais para dizer o que guardam: um double pode ser uma nota, um preço, uma altura. Com using você dá um apelido a um tipo, e o código fica mais curto e mais fácil de ler. Nesta aula você vai criar apelidos com using, reconhecer a forma antiga typedef e entender o que um apelido não faz.

Todos os programas desta aula foram compilados com o g++ 15 na máquina fictícia da Ana, com o comando padrão do guia: g++ -std=c++23 -Wall -Wextra arquivo.cpp -o programa. Você pode repetir cada um no editor do guia.

A ideia: um apelido, não uma pessoa nova

A Ana se chama Ana Beatriz, mas a família a chama de "Bia". Quando a mãe diz "a Bia chegou", ninguém pensa que entrou uma pessoa nova na casa: é a mesma Ana Beatriz, com outro nome.

Um apelido de tipo é isso. using Nota = double; diz ao compilador: "quando eu escrever Nota, entenda double". O tipo é exatamente o mesmo. O ganho é para quem lê o código: Nota media(Nota a, Nota b) conta mais que double media(double a, double b).

Compare com as aulas anteriores: struct e enum class criam tipos novos, diferentes de todos os outros. using e typedef só dão outro nome a um tipo que já existe.

1. using: o jeito moderno

#include <iostream>

using Nota = double;

Nota media(Nota a, Nota b) {
    return (a + b) / 2;
}

int main() {
    Nota prova = 8.0;
    Nota trabalho = 6.5;
    std::cout << "Média: " << media(prova, trabalho) << '\n';

    double comum = prova;
    Nota outra = 10;
    std::cout << comum << ' ' << outra << '\n';
}

using

Palavra-chave (em inglês, "usando"). Aqui ela começa um apelido. A mesma palavra tem outros usos em C++, como using enum (veja Enums) e using namespace (veja Namespaces); o que decide é o que vem depois.

Nota

O apelido novo. Como nos tipos próprios, começa com maiúscula.

= double;

O tipo verdadeiro. Leia a linha inteira como "Nota é igual a double".

Nota media(Nota a, Nota b)

A partir daí, Nota serve em qualquer lugar onde serviria um double: variáveis, parâmetros, retorno.

double comum = prova;

Como é o mesmo tipo, Nota e double se misturam à vontade, sem conversão.

$ g++ -std=c++23 -Wall -Wextra nota.cpp -o nota
$ ./nota
Média: 7.25
8 10

Outra vantagem: se um dia a Ana decidir que as notas devem ser float, ela muda uma linha (using Nota = float;) em vez de caçar todos os double do programa, que também podem ser preços, alturas…

#include <iostream>

// crie aqui o apelido Preco para double

double total(double unitario, int quantidade) {
    return unitario * quantidade;
}

int main() {
    double caderno = 12.5;
    std::cout << "Total: R$ " << total(caderno, 3) << '\n';
}

#include <iostream>

using Preco = double;

Preco total(Preco unitario, int quantidade) {
    return unitario * quantidade;
}

int main() {
    Preco caderno = 12.5;
    std::cout << "Total: R$ " << total(caderno, 3) << '\n';
}

2. O apelido não é um tipo novo

Isso tem uma consequência que surpreende: para o compilador, Nota e double são indistinguíveis. Ele não protege você de misturar uma nota com um preço, como o enum class faria. E duas funções que só diferem por um apelido são, na verdade, a mesma função:

#include <iostream>

using Nota = double;

void mostrar(double x) {
    std::cout << "double: " << x << '\n';
}

void mostrar(Nota n) {
    std::cout << "nota: " << n << '\n';
}

int main() {
    mostrar(8.5);
}

$ g++ -std=c++23 -Wall -Wextra mesmotipo.cpp -o mesmotipo
mesmotipo.cpp:9:6: error: redefinition of ‘void mostrar(Nota)’
    9 | void mostrar(Nota n) {
      |      ^~~~~~~
mesmotipo.cpp:5:6: note: ‘void mostrar(double)’ previously defined here
    5 | void mostrar(double x) {
      |      ^~~~~~~

redefinition of ‘void mostrar(Nota)’ = "redefinição de mostrar(Nota)". A nota de baixo explica: ela já tinha sido definida como mostrar(double), que é a mesma coisa. Na sobrecarga de funções, os parâmetros precisam ter tipos de verdade diferentes; um apelido não conta. Se você precisa que Nota e Preco sejam tipos diferentes, crie uma struct para cada um.

3. typedef: o jeito antigo

Antes do C++11, os apelidos eram feitos com typedef (de type definition, "definição de tipo"), que vem da linguagem C. Ele faz exatamente a mesma coisa, mas na ordem inversa: primeiro o tipo verdadeiro, depois o apelido, como se você declarasse uma variável.

#include <iostream>

typedef double Nota;
typedef unsigned int Contador;

int main() {
    Nota n = 7.5;
    Contador alunos = 30;
    std::cout << n << ' ' << alunos << '\n';
}

$ g++ -std=c++23 -Wall -Wextra typedef.cpp -o typedef
$ ./typedef
7.5 30

Com using, o nome novo fica sempre à esquerda do =, como numa variável (int x = 5;). Com typedef, você precisa achar o apelido no fim da linha. A diferença fica gritante com tipos complicados, como um ponteiro para função:

#include <iostream>

typedef void (*AcaoAntiga)(int);
using Acao = void (*)(int);

void dizer(int n) {
    std::cout << "Número " << n << '\n';
}

int main() {
    AcaoAntiga a = dizer;
    Acao b = dizer;
    a(1);
    b(2);
}

$ g++ -std=c++23 -Wall -Wextra ponteirofuncao.cpp -o ponteirofuncao
$ ./ponteirofuncao
Número 1
Número 2

Não se preocupe com o que é um ponteiro para função; repare só onde está o nome. No typedef, o apelido AcaoAntiga fica escondido no meio, entre parênteses. No using, Acao está na frente, e o tipo inteiro do outro lado do =.

Qual usar: using no código novo. Conheça o typedef porque ele está em todo lugar, inclusive dentro da própria biblioteca padrão. Dois exemplos reais, dos cabeçalhos do g++ 15 na máquina da Ana:

$ grep -n 'size_t;' /usr/include/x86_64-linux-gnu/c++/15/bits/c++config.h | head -1
338:  typedef __SIZE_TYPE__ 	size_t;
$ grep -n 'typedef basic_string<char> *string;' /usr/include/c++/15/bits/stringfwd.h
79:  typedef basic_string<char>    string;

Isso mesmo: o std::string que você usa desde o Nível 1 é um apelido para std::basic_string<char>, e o std::size_t (o tipo de v.size()) é um apelido para um inteiro sem sinal. É por isso que algumas mensagens de erro falam em basic_string<char>: o compilador às vezes mostra o nome verdadeiro, não o apelido.

4. Apelidos para tipos compridos

O uso mais comum de using no dia a dia é encurtar tipos que se repetem pelo programa. Um vetor de alunos, por exemplo:

#include <iostream>
#include <string>
#include <vector>

struct Aluno {
    std::string nome;
    double nota = 0.0;
};

using Turma = std::vector<Aluno>;

double media(const Turma& turma) {
    double soma = 0.0;
    for (const auto& a : turma) {
        soma += a.nota;
    }
    return soma / turma.size();
}

int main() {
    Turma manha = {{"Ana", 8.5}, {"Bruno", 6.0}};
    Turma tarde = {{"Carla", 9.5}, {"Davi", 7.0}, {"Eva", 8.0}};
    std::cout << "Manhã: " << media(manha) << '\n';
    std::cout << "Tarde: " << media(tarde) << '\n';
}

$ g++ -std=c++23 -Wall -Wextra turma.cpp -o turma
$ ./turma
Manhã: 7.25
Tarde: 8.16667

O ganho cresce com o tamanho do tipo. A agenda de telefones da Ana usa um std::map: uma tabela que liga uma chave (o nome) a um valor (o telefone). Você vai estudá-lo em std::map; aqui, basta saber que std::map<std::string, std::string> é "uma tabela de texto para texto". Sem apelido, esse nome aparece em todo lugar:

#include <iostream>
#include <map>
#include <string>

void mostrar(const std::map<std::string, std::string>& agenda) {
    for (const auto& contato : agenda) {
        std::cout << contato.first << ": " << contato.second << '\n';
    }
}

int main() {
    std::map<std::string, std::string> amigos;
    amigos["Bruno"] = "(11) 98765-4321";
    mostrar(amigos);
}

Com apelido:

#include <iostream>
#include <map>
#include <string>

using Agenda = std::map<std::string, std::string>;

void mostrar(const Agenda& agenda) {
    for (const auto& contato : agenda) {
        std::cout << contato.first << ": " << contato.second << '\n';
    }
}

int main() {
    Agenda amigos;
    amigos["Bruno"] = "(11) 98765-4321";
    amigos["Carla"] = "(21) 91234-5678";
    amigos["Ana"] = "(31) 99999-0000";
    mostrar(amigos);
}

$ g++ -std=c++23 -Wall -Wextra agenda.cpp -o agenda
$ ./agenda
Ana: (31) 99999-0000
Bruno: (11) 98765-4321
Carla: (21) 91234-5678

using Agenda = std::map<std::string, std::string>;

Um nome curto, que diz para que o tipo serve, no lugar de um nome longo, que diz como ele é feito.

amigos["Bruno"] = "(11) 98765-4321";

Guarda o telefone do Bruno na tabela.

contato.first / contato.second

Cada item da tabela tem a chave (first, "primeiro") e o valor (second, "segundo"). O map mostra os nomes em ordem alfabética.

5. Apelidos com "buraco": alias de template

Só para você reconhecer quando encontrar: um apelido pode deixar uma parte do tipo em aberto, para ser preenchida depois, entre < >. Isso se chama alias de template, e só funciona com using (o typedef não consegue).

#include <iostream>
#include <map>
#include <string>
#include <vector>

template <typename T>
using Lista = std::vector<T>;

template <typename V>
using Tabela = std::map<std::string, V>;

int main() {
    Lista<int> idades = {20, 19, 22};
    Lista<std::string> nomes = {"Ana", "Bruno"};
    Tabela<double> notas = {{"Ana", 8.5}};
    std::cout << idades.size() << ' ' << nomes[1] << ' ' << notas["Ana"] << '\n';
}

$ g++ -std=c++23 -Wall -Wextra template.cpp -o template
$ ./template
3 Bruno 8.5

Lista<int> vira std::vector<int>; Tabela<double> vira std::map<std::string, double>. O T e o V são os "buracos". Como isso funciona por dentro é assunto de Templates de Classe, no Nível 3.

Quando dá errado

#include <iostream>

Nota dobro(Nota n) {
    return n * 2;
}

using Nota = double;

int main() {
    std::cout << dobro(4.5) << '\n';
}

$ g++ -std=c++23 -Wall -Wextra antes.cpp -o antes
antes.cpp:3:1: error: ‘Nota’ does not name a type
    3 | Nota dobro(Nota n) {
      | ^~~~
antes.cpp: In function ‘int main()’:
antes.cpp:10:18: error: ‘dobro’ was not declared in this scope
   10 |     std::cout << dobro(4.5) << '\n';
      |                  ^~~~~

$ g++ -std=c++23 -Wall -Wextra typedefinvertido.cpp -o typedefinvertido
typedefinvertido.cpp:1:9: error: ‘Nota’ does not name a type
    1 | typedef Nota double;
      |         ^~~~
typedefinvertido.cpp: In function ‘int main()’:
typedefinvertido.cpp:4:5: error: ‘Nota’ was not declared in this scope
    4 |     Nota n = 7.5;
      |     ^~~~

#include <iostream>

using Nota = double;

Nota dobro(Nota n) {
    return n * 2;
}

int main() {
    std::cout << dobro(4.5) << '\n';
}

#include <iostream>

Nota dobro(Nota n) {
    return n * 2;
}

using Nota = double;

int main() {
    std::cout << dobro(4.5) << '\n';
}

Referência rápida

Exercícios

Missão final: a turma com apelido

#include <iostream>
#include <string>
#include <vector>

struct Aluno {
    std::string nome;
    double nota = 0.0;
};

// crie aqui o apelido Turma

double media(const std::vector<Aluno>& turma) {
    double soma = 0.0;
    for (const auto& a : turma) {
        soma += a.nota;
    }
    return soma / turma.size();
}

int main() {
    std::vector<Aluno> turma = {{"Ana", 8.5}, {"Bruno", 6.0}, {"Carla", 9.5}, {"Davi", 7.0}};
    std::cout << "Média da turma: " << media(turma) << '\n';
}

#include <iostream>
#include <string>
#include <vector>

struct Aluno {
    std::string nome;
    double nota = 0.0;
};

using Turma = std::vector<Aluno>;

double media(const Turma& turma) {
    double soma = 0.0;
    for (const auto& a : turma) {
        soma += a.nota;
    }
    return soma / turma.size();
}

int main() {
    Turma turma = {{"Ana", 8.5}, {"Bruno", 6.0}, {"Carla", 9.5}, {"Davi", 7.0}};
    std::cout << "Média da turma: " << media(turma) << '\n';
}

Resumo

• using Nota = double; cria um apelido: um nome a mais para um tipo que já existe.
• O apelido não cria um tipo novo: Nota e double se misturam e não servem para sobrecarga. Para um tipo novo, use struct ou enum class.
• typedef double Nota; é a forma antiga, com o apelido no fim. Prefira using.
• Use apelidos para tipos compridos (using Agenda = std::map<std::string, std::string>;) e para dar significado (Nota, Turma).
• O apelido precisa vir antes do primeiro uso, senão: does not name a type.
• std::string e std::size_t são apelidos da própria biblioteca padrão.