C++: Novos Recursos do C++17/20

Última atualização: 2026-08-26

Na aula 47, aprendemos sobre metaprogramação de templates.

Agora, vamos aprender sobre os novos recursos do C++17 e C++20.

Esses novos recursos tornam o C++ mais conciso, seguro e poderoso.

1. Novos Recursos do C++17

(1) 1.1 Binding Estruturado

Recurso: Desempacotar convenientemente de tuple, pair e struct.

Exemplo: Binding Estruturado (Dificuldade ⭐)

▶ Exemplo 2: Exemplo de Código (Dificuldade ⭐)

#include <iostream>
#include <tuple>

int main() {
	std::tuple<int, std::string, double> t = {1, "Hello", 3.14};
	
	// C++17: Binding estruturado
	auto [id, name, score] = t;
	
	std::cout << "ID: " << id << std::endl;
	std::cout << "Name: " << name << std::endl;
	std::cout << "Score: " << score << std::endl;
	
	return 0;
}

Saída:

ID: 1
Name: Hello
Score: 3.14

(2) 1.2 if constexpr

Recurso: if em tempo de compilação, compilando código seletivamente com base em condições.

Exemplo: if constexpr (Dificuldade ⭐⭐)

#include <iostream>
#include <type_traits>

template<typename T>
auto process(T value) {
	if constexpr (std::is_integral_v<T>) {
		return value * 2; // Inteiro: dobrar
	} else {
		return value; // Outro: retornar como está
	}
}

int main() {
	std::cout << process(10) << std::endl; // 20
	std::cout << process(3.14) << std::endl; // 3.14
	
	return 0;
}

(3) 1.3 Fold Expressions

Recurso: Simplificar templates variádicos.

Exemplo: Fold Expression (Dificuldade ⭐⭐)

#include <iostream>

template<typename... Args>
void print(Args... args) {
	(std::cout << ... << args) << std::endl; // Fold expression
}

int main() {
	print(1, 2, 3, 4, 5); // Saída: 12345
	return 0;
}

(4) 1.4 Outros Recursos do C++17

2. Novos Recursos do C++20

(1) 2.1 Concepts

Recurso: Restringir parâmetros de template para mensagens de erro mais amigáveis.

Exemplo: Restringindo Templates com Concepts (Dificuldade ⭐⭐⭐)

#include <iostream>
#include <concepts>

// Restringir T a ser um tipo integral
template<typename T>
requires std::integral<T>
T doubleValue(T x) {
	return x * 2;
}

int main() {
	std::cout << doubleValue(10) << std::endl; // 20
	// std::cout << doubleValue(3.14) << std::endl; // ❌ Erro de compilação (claro)
	
	return 0;
}

(2) 2.2 Biblioteca Ranges

Recurso: Uma forma mais concisa de chamar algoritmos STL.

Exemplo: Usando ranges (Dificuldade ⭐⭐)

#include <iostream>
#include <ranges>
#include <vector>

int main() {
	std::vector<int> v = {1, 2, 3, 4, 5};
	
	// C++20: ranges
	auto result = v | std::views::filter([](int x) { return x % 2 == 0; })
					| std::views::transform([](int x) { return x * 10; });
	
	for (int x : result) {
		std::cout << x << " "; // Saída: 20 40
	}
	std::cout << std::endl;
	
	return 0;
}

(3) 2.3 Corrotinas

Recurso: Suporte a corrotinas (funções que podem pausar/retomar).

Exemplo: Corrotina Simples (Dificuldade ⭐⭐⭐⭐)

#include <iostream>
#include <coroutine>

// Corrotinas em C++20 são complexas; implementação específica omitida aqui
// Conceito: corrotinas podem pausar a execução e retomar depois

int main() {
	// Exemplo de corrotina C++20 (simplificado)
	std::cout << "C++20 Coroutines" << std::endl;
	return 0;
}

(4) 2.4 Outros Recursos do C++20

3. Escolhendo um Padrão

(1) 3.1 Qual Padrão Você Deve Usar?

4. Prática: Refatorando Código com C++17

▶ Exemplo 1: Simplificando Código com Binding Estruturado (Dificuldade ⭐⭐)

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

int main() {
	std::map<int, std::string> students = {{1, "Zhang San"}, {2, "Li Si"}};
	
	// C++17: Binding estruturado para iterar map
	for (const auto& [id, name] : students) {
		std::cout << id << ": " << name << std::endl;
	}
	
	return 0;
}

Saída:

1: Zhang San
2: Li Si

▶ Exemplo 3: Dedução de tipo auto (Dificuldade ⭐)

#include <iostream>
#include <vector>

int main() {
    auto x = 10;           // int
    auto y = 3.14;         // double
    auto name = "Hello";   // const char*
    
    std::vector<int> nums = {1, 2, 3, 4, 5};
    auto it = nums.begin(); // vector<int>::iterator
    
    std::cout << "x = " << x << std::endl;
    std::cout << "y = " << y << std::endl;
    std::cout << "name = " << name << std::endl;
    
    return 0;
}

Saída:

x = 10
y = 3.14
name = Hello

Saída esperada:

x = 10
y = 3.14
name = Hello

❓ Perguntas Frequentes

P: Devo usar o padrão mais recente? R: Não necessariamente. Considere: - Suporte do compilador - Familiaridade da equipe - Requisitos do projeto

P: Como habilito C++17/20? R: Adicione flags ao compilar: bash g++ -std=c++17 main.cpp g++ -std=c++20 main.cpp

P: O que há de novo no C++23? R:- Biblioteca padrão modular - Biblioteca de networking - Mais algoritmos Ranges

📖 Resumo

📝 Exercícios

1. Básico (Dificuldade ⭐): Reescreva um trecho de código C++ antigo (com tipos explícitos, for tradicional, NULL) usando auto, for baseado em range e nullptr.

2. Intermediário (Dificuldade ⭐⭐): Use binding estruturado (C++17) para desempacotar um valor de retorno pair ou tuple e compare com a abordagem tradicional .first/.second.

3. Desafio (Dificuldade ⭐⭐⭐): Use if constexpr (C++17) para implementar ramificação em tempo de compilação — escreva um template de função que aplique lógica de processamento diferente para tipos inteiros e tipos de ponto flutuante.

• C++11: auto/nullptr/range-for/lambda/smart pointers
• C++14: generic lambda/make_unique
• C++17: binding estruturado/if constexpr/string_view/filesystem
• C++20: modules/corrotinas/concepts/Ranges
• Este curso usa C++17, equilibrando novos recursos e compatibilidade

Próxima aula: Otimização de Desempenho (#49)

Equipe Técnica Web-Tutorial

Uma plataforma de tutoriais mantida por diversos desenvolvedores. Cada tutorial é escrito e revisado por profissionais da área correspondente. Trabalhamos para manter nosso conteúdo preciso e confiável — se encontrar algum problema, avise-nos.

Sobre Nós