C++ Matemática (cmath)

Os operadores + - * / % fazem as contas básicas. Mas e a raiz quadrada? E "2 elevado a 10"? E arredondar a média da Ana? Para isso, o C++ traz uma caixa de ferramentas de matemática pronta, a biblioteca <cmath>. Nesta aula você vai usar as funções mais comuns dela, uma de cada vez, e ver o que acontece quando a conta não tem resposta, como a raiz de um número negativo.

Todos os programas desta aula foram compilados com o g++ 15.2 na máquina fictícia da Ana (usuária ana, computador notebook), com o comando padrão do guia, g++ -std=c++23 -Wall -Wextra arquivo.cpp -o programa (explicado em Compilar com g++). Você pode repetir cada um no editor do guia, que compila C++ de verdade no navegador.

A ideia: a calculadora científica

Lembra da calculadora da escola? A simples tem só + − × ÷. A científica tem botões a mais: √, x², |x|, π. Os operadores do C++ (aula Operadores Aritméticos) são a calculadora simples. A <cmath> é a fileira de botões científicos.

Cada "botão" é uma função: um pedaço de código pronto, com um nome, que recebe valores entre parênteses e devolve um resultado. Você vai aprender a criar as suas em Funções; por enquanto, basta saber chamar as que já existem:

O nome cmath quer dizer "C math", a matemática que veio da linguagem C. O c no começo marca as bibliotecas herdadas do C (como <cstdlib> e <cstdio>).

1. Raiz e potência: sqrt e pow

Para usar as funções, inclua <cmath> no topo do arquivo, ao lado do <iostream>:

#include <iostream>
#include <cmath>

int main() {
    std::cout << std::sqrt(25) << "\n";
    std::cout << std::sqrt(2) << "\n";
    std::cout << std::pow(2, 10) << "\n";
    std::cout << std::pow(1.5, 2) << "\n";
    std::cout << std::pow(27, 1.0 / 3) << "\n";
    std::cout << std::cbrt(27) << "\n";
}

#include <cmath>

Traz as funções de matemática para o seu programa. Sem essa linha, o compilador não conhece std::sqrt (o erro está em "Quando dá errado").

std::

O "sobrenome" das coisas da biblioteca padrão (standard). std::sqrt = "o sqrt da biblioteca padrão". A aula Namespaces explica o porquê.

sqrt(25)

square root, raiz quadrada. O valor entre parênteses é o argumento: o número de que você quer a raiz.

pow(2, 10)

power, potência: a base (2) elevada ao expoente (10). Dois argumentos, separados por vírgula. Em C++ não existe operador ^ de potência: 2 ^ 10 compila, mas é outra coisa (uma operação de bits) e dá 8. O g++ 15 desconfia e avisa: warning: result of ‘2^10’ is 8; did you mean ‘1 << 10’ (1024)? [-Wxor-used-as-pow].

pow(27, 1.0 / 3)

Elevar a 1/3 é tirar a raiz cúbica. Repare no 1.0: com 1 / 3, a divisão de inteiros daria 0 (aula Operadores Aritméticos).

cbrt(27)

cube root, raiz cúbica, direto.

$ g++ -std=c++23 -Wall -Wextra raiz.cpp -o raiz
$ ./raiz
5
1.41421                  « √2 tem infinitas casas; o cout mostra 6 algarismos
1024
2.25
3
3

Duas coisas para reparar:

• O resultado é double (número com vírgula, aula float e double), mesmo quando a conta dá "redondo". std::sqrt(25) devolve 5.0; o cout só esconde o .0.
• O cout mostra no máximo 6 algarismos. Por isso √2 virou 1.41421. Números grandes viram notação científica: std::pow(2, 30) aparece como 1.07374e+09 (1,07374 × 10⁹). Para escolher quantas casas mostrar, veja Formatar com iomanip e std::format e std::print.

$ ldd ./raiz
	linux-vdso.so.1 (0x00007ae3a075e000)
	libstdc++.so.6 => /usr/lib/x86_64-linux-gnu/libstdc++.so.6 (0x00007ae3a0400000)
	libm.so.6 => /usr/lib/x86_64-linux-gnu/libm.so.6 (0x00007ae3a02da000)     « aqui
	libc.so.6 => /usr/lib/x86_64-linux-gnu/libc.so.6 (0x00007ae3a0000000)
	/lib64/ld-linux-x86-64.so.2 (0x00007ae3a0760000)
	libgcc_s.so.1 => /usr/lib/x86_64-linux-gnu/libgcc_s.so.1 (0x00007ae3a0708000)

#include <iostream>
#include <cmath>

int main() {
    std::cout << "Raiz de 144: " << 0 << "\n";
    std::cout << "3 elevado a 4: " << 0 << "\n";
}

#include <iostream>
#include <cmath>

int main() {
    std::cout << "Raiz de 144: " << std::sqrt(144) << "\n";
    std::cout << "3 elevado a 4: " << std::pow(3, 4) << "\n";
}

2. Valor absoluto: std::abs

O valor absoluto é o número "sem o sinal": a distância até o zero. |−7| = 7 e |7| = 7. Serve, por exemplo, para saber de quanto é uma dívida sem se preocupar se o saldo está negativo.

#include <iostream>
#include <cmath>

int main() {
    std::cout << std::abs(-7) << "\n";
    std::cout << std::abs(-2.5) << "\n";
    std::cout << abs(-2.5) << "\n";
}

$ g++ -std=c++23 -Wall -Wextra abs.cpp -o abs
$ ./abs
7
2.5
2                        « abs sem std:: cortou o .5, e o g++ não avisou nada!

As duas primeiras linhas estão certas. A terceira mostrou 2 em vez de 2.5, e o compilador ficou calado mesmo com -Wall -Wextra. O que aconteceu?

• O std::abs do C++ tem uma versão para cada tipo de número: uma para int, uma para double, uma para long… O compilador escolhe a certa olhando o argumento. Isso se chama sobrecarga (aula Sobrecarga de Funções).
• O abs sem std:: é o antigo da linguagem C, que só conhece int. O -2.5 foi convertido para int (virou -2, perdendo o .5) antes do cálculo.

Só a opção -Wconversion (que não faz parte de -Wall -Wextra, aula Avisos) denuncia a perda:

$ g++ -std=c++23 -Wall -Wextra -Wconversion abs.cpp -o abs
abs.cpp: In function ‘int main()’:
abs.cpp:7:22: warning: conversion from ‘double’ to ‘int’ changes value from ‘-2.5e+0’ to ‘-2’ [-Wfloat-conversion]
    7 |     std::cout << abs(-2.5) << "\n";
      |                      ^~~~

Tradução: "conversão de double para int muda o valor de −2,5 para −2". O outro compilador do laboratório, o Clang (o mesmo do editor do guia), avisa mesmo sem -Wconversion, e ainda sugere a correção:

$ clang++ -std=c++23 -Wall -Wextra abs.cpp -o abs
abs.cpp:7:18: warning: using integer absolute value function 'abs' when argument is of floating point type [-Wabsolute-value]
    7 |     std::cout << abs(-2.5) << "\n";
      |                  ^
abs.cpp:7:18: note: use function 'std::abs' instead
    7 |     std::cout << abs(-2.5) << "\n";
      |                  ^~~
      |                  std::abs
abs.cpp:7:22: warning: implicit conversion from 'double' to 'int' changes value from -2.5 to -2 [-Wliteral-conversion]
    7 |     std::cout << abs(-2.5) << "\n";
      |                  ~~~ ^~~~
2 warnings generated.

3. Arredondar: round, floor, ceil e trunc

Existem quatro jeitos de transformar 2.7 num número inteiro, e cada um serve para uma situação:

#include <iostream>
#include <cmath>

int main() {
    double v[] = {2.4, 2.5, 2.7, -2.5, -2.7};
    for (double x : v) {
        std::cout << x << ": round=" << std::round(x) << " floor=" << std::floor(x)
                  << " ceil=" << std::ceil(x) << " trunc=" << std::trunc(x) << "\n";
    }
}

Este programa usa duas coisas de aulas futuras só para não repetir a mesma linha cinco vezes: uma lista de números (double v[], aula Arrays) e um for que passa por cada um deles, chamando-o de x (aula for de Intervalo). Foque nas funções:

$ ./arred
2.4: round=2 floor=2 ceil=3 trunc=2
2.5: round=3 floor=2 ceil=3 trunc=2
2.7: round=3 floor=2 ceil=3 trunc=2
-2.5: round=-3 floor=-3 ceil=-2 trunc=-2    « nos negativos, "baixo" é -3
-2.7: round=-3 floor=-3 ceil=-2 trunc=-2

Nos positivos, floor e trunc dão o mesmo resultado. A diferença aparece nos negativos: o floor desce (−2,5 → −3), o trunc só corta (−2,5 → −2). Pense num termômetro: abaixo de zero, "descer" é ficar mais frio.

Quando usar cada um

Arredondar com uma casa decimal

As quatro funções sempre arredondam para um inteiro. Para ficar com uma casa, o truque é multiplicar por 10, arredondar e dividir por 10:

#include <iostream>
#include <cmath>

int main() {
    double media = 6.75;
    std::cout << "Média: " << media << "\n";
    std::cout << "Arredondada: " << std::round(media) << "\n";
    std::cout << "Com 1 casa: " << std::round(media * 10) / 10 << "\n";
}

$ ./nota
Média: 6.75
Arredondada: 7
Com 1 casa: 6.8          « 67.5 → round → 68 → ÷10 → 6.8

Se a ideia é só mostrar o número com uma casa (e não mudar o valor guardado), é mais simples pedir isso na hora de imprimir, com iomanip ou std::format.

#include <iostream>
#include <cmath>

int main() {
    int ovos = 23;
    int caixas = ovos / 6;
    std::cout << "Caixas: " << caixas << "\n";
}

#include <iostream>
#include <cmath>

int main() {
    int ovos = 23;
    double caixas = std::ceil(ovos / 6.0);
    std::cout << "Caixas: " << caixas << "\n";
}

4. Maior e menor: std::max e std::min

Para escolher o maior ou o menor de dois valores, use std::max e std::min. Eles não moram na <cmath>, e sim na <algorithm> (algoritmos), outra biblioteca padrão:

#include <iostream>
#include <algorithm>

int main() {
    std::cout << std::max(3, 7) << "\n";
    std::cout << std::min(3, 7) << "\n";
    std::cout << std::max({8, 3, 9, 5}) << "\n";
}

$ ./maxmin
7
3
9                        « com chaves { }, aceita quantos valores você quiser

std::max(3, 7)

Devolve o maior dos dois: 7.

std::min(3, 7)

Devolve o menor: 3.

std::max({8, 3, 9, 5})

Com uma lista entre chaves, compara todos de uma vez. Repare: parênteses e chaves.

Os dois valores precisam ser do mesmo tipo. std::max(3, 7.5) (um int e um double) não compila; veja o erro em "Quando dá errado". Um uso comum é "não deixar passar do limite": std::min(nota, 10.0) garante que a nota nunca passe de 10, mesmo com bônus.

5. O número π: std::numbers::pi C++20

Desde o C++20, o π vem pronto, com todas as casas que um double consegue guardar, na biblioteca <numbers>:

#include <iostream>
#include <numbers>

int main() {
    double raio = 2.0;
    double area = std::numbers::pi * raio * raio;
    std::cout << "Área: " << area << "\n";
}

$ g++ -std=c++23 -Wall -Wextra pi.cpp -o pi
$ ./pi
Área: 12.5664

#include <numbers>

A biblioteca das constantes matemáticas (C++20).

std::numbers::pi

Leia de trás para frente: "o pi, que está em numbers, que está em std". Não tem parênteses: é um valor, não uma função.

raio * raio

O raio ao quadrado. Também daria std::pow(raio, 2) (com <cmath>).

Na mesma biblioteca estão std::numbers::e (2.71828…, o número de Euler) e std::numbers::sqrt2 (√2 = 1.41421…).

$ g++ -Wall -Wextra pi.cpp -o pi
pi.cpp: In function ‘int main()’:
pi.cpp:6:24: error: ‘std::numbers’ has not been declared
    6 |     double area = std::numbers::pi * raio * raio;
      |                        ^~~~~~~

6. Distância entre dois pontos: std::hypot

A casa da Ana fica 3 quarteirões a leste e 4 ao norte da padaria. Em linha reta, qual a distância? É o teorema de Pitágoras: √(3² + 4²) = 5. A função std::hypot (de hypotenuse, hipotenusa) faz essa conta de uma vez:

#include <iostream>
#include <cmath>

int main() {
    std::cout << std::hypot(3, 4) << "\n";
    std::cout << std::sqrt(3 * 3 + 4 * 4) << "\n";
}

$ ./hypot
5
5

As duas linhas dão o mesmo resultado. O hypot é mais curto de ler e, com números muito grandes ou muito pequenos, mais preciso (ele evita que o quadrado "estoure" no meio da conta).

7. Conta sem resposta: nan e inf

Não existe raiz quadrada de número negativo nos números reais. O que o C++ faz com std::sqrt(-1)? Ele não trava o programa: devolve um valor especial chamado NaN (Not a Number, "não é um número").

#include <iostream>
#include <cmath>

int main() {
    double r = std::sqrt(-1);
    std::cout << r << "\n";
    std::cout << std::log(0) << "\n";
    std::cout << 1.0 / 0 << "\n";
    std::cout << std::isnan(r) << "\n";
    std::cout << (r == r) << "\n";
}

$ g++ -std=c++23 -Wall -Wextra nan.cpp -o nan
nan.cpp: In function ‘int main()’:
nan.cpp:8:22: warning: division by zero [-Wdiv-by-zero]
    8 |     std::cout << 1.0 / 0 << "\n";
      |                  ~~~~^~~
$ ./nan
-nan                     « sqrt(-1): "não é um número" (o sinal de menos não significa nada útil)
-inf                     « log(0): menos infinito
inf                      « 1.0 / 0: infinito
1                        « isnan(r) é verdadeiro (1 = true)
0                        « um NaN não é igual nem a ele mesmo!

O perigo é que o nan contamina tudo: qualquer conta com ele dá nan, e o programa segue em frente mostrando lixo. Para descobrir se um resultado é nan, use std::isnan(x) (não x == x, que é um truque confuso). Na aula if e else você vai aprender a conferir antes: "se o número for negativo, avise o usuário em vez de calcular a raiz".

Formas diferentes de fazer a mesma conta

Quando dá errado

#include <iostream>

int main() {
    std::cout << std::sqrt(16) << "\n";
}

$ g++ -std=c++23 -Wall -Wextra semcmath.cpp -o semcmath
semcmath.cpp: In function ‘int main()’:
semcmath.cpp:4:23: error: ‘sqrt’ is not a member of ‘std’; did you mean ‘sort’?
    4 |     std::cout << std::sqrt(16) << "\n";
      |                       ^~~~
      |                       sort

    std::cout << std::max(3, 7.5) << "\n";

$ g++ -std=c++23 -Wall -Wextra maxmin.cpp -o maxmin
maxmin.cpp: In function ‘int main()’:
maxmin.cpp:8:26: error: no matching function for call to ‘max(int, double)’
    8 |     std::cout << std::max(3, 7.5) << "\n";
      |                  ~~~~~~~~^~~~~~~~
maxmin.cpp:8:26: note: there are 4 candidates
…
maxmin.cpp:8:26: note:   deduced conflicting types for parameter ‘const _Tp’ (‘int’ and ‘double’)

Referência rápida

A <cmath> tem muito mais: std::sin, std::cos, std::tan (trigonometria, com ângulos em radianos), std::log (logaritmo natural), std::log10, std::exp. Elas funcionam do mesmo jeito: inclua <cmath> e chame com std::.

Exercícios

Missão final: o canteiro redondo

#include <iostream>
#include <cmath>
#include <numbers>

int main() {
    double raio = 5.0;
    // calcule a área aqui

    // e quantos sacos de 10 m² ela precisa
}

#include <iostream>
#include <cmath>
#include <numbers>

int main() {
    double raio = 5.0;
    double area = std::numbers::pi * std::pow(raio, 2);
    double sacos = std::ceil(area / 10);
    std::cout << "Área: " << area << "\n";
    std::cout << "Sacos: " << sacos << "\n";
}

Resumo

• #include <cmath> traz as funções de matemática. Chame-as com std::: std::sqrt(25).
• std::sqrt (raiz), std::pow(b, e) (potência; C++ não tem ^ de potência), std::cbrt (raiz cúbica). O resultado é double.
• Use sempre std::abs: o abs sem std:: pode ser a versão do C, só para int, e transformar 2.5 em 2 sem aviso do g++.
• round (mais perto), floor (para baixo), ceil (para cima), trunc (corta). Cuidado com a divisão de inteiros antes do arredondamento.
• std::max e std::min vêm de <algorithm> e exigem dois valores do mesmo tipo.
• std::numbers::pi (<numbers>, C++20) precisa de -std=c++20 ou mais novo.
• std::sqrt(-1) não trava: devolve nan. Divisão de double por zero dá inf. Teste com std::isnan.
• Em C++, não precisa de -lm: o g++ já liga a biblioteca de matemática.