Procedimentos em C++, como em C, são "funções" que não retornam nenhum tipo de valor ao término de sua execução. A palavra reservada void é utilizada para informar que não há retorno.

Sintaxe

void nome_procedimento()
{
  //corpo procedimento
}

Onde

void: palavra reservada que não haverá retorno e que a declaração é uma procedimento.

Para invocar um procedimento, utilizamos seu nome em um local desejado para seu uso:

Exemplo 1

#include <iostream>

void procedimento()
{
    cout << "um procedimento sem retorno";
}

void main()
{
    procedimento();
}

Saída

um procedimento sem retorno

Função em C++, diferente de procedimento, retornam um ou mais valores durante a sua execução. Qualquer tipo de dado dentre os já estudados e do usuário pode ser utilizado como retorno além dos tipos fornecidos pela biblioteca nativa de C++.

Sintaxe

tipo_retorno nome_funcao()
{
  //corpo função

  return valor;
}

Onde

tipo_retorno: Tipo de dado que será retornado pela função
return: Comando para retornar um valor de uma função

Para invocar uma função, utilizamos seu nome em um local desejado para seu uso:

Exemplo 2

#include <iostream>

int minha_funcao()
{
    int variavel;

    //uso omitido

    return variavel;
}

void main()
{
    int retorno = minha_funcao();
} 

Saída

-

As funções e procedimentos podem ser criados antes ou depois da função main, levando em consideração que possuímos apenas um arquivo main.c. Na declaração de funções e procedimentos, podemos utilizar as "regras":

1. Criando a função/procedimento antes da main, essa função pode ser chamada normalmente.
2. Criando a função/procedimento após a main, um protótipo da função deve ser declarado antes da main(main.c).

Exemplo 3

#include <iostream>

void funcao2(); //protótipo da função 2

void funcao1()
{
    printf("funcao1 \n");
}

int main ()
{
    funcao1();
    funcao2();
    return 0;
}

void funcao2()
{
    printf("funcao2 \n");    
}

Saída

funcao1
funcao2

Em uma futura seção, vamos aprender a separa os nossos programas em arquivos .cpp e .hpp para melhor organização. A utilização do exemplo acima foi feita apenas para compreensão, não sendo recomendada para programas mais complexos.

Para a passagem de argumentos para funções em C++, semelhante à C, declaramos todos os parâmetros de acordo com a sintaxe já vista:

Sintaxe

tipo_retorno nome_funcao(tipo_dado param1, tipo_dado param2, tipo_dado paramN)
{
  //corpo função
  return valor_retorno; 
}

void nome_procedimento(tipo_dado param1, tipo_dado param2,tipo_dado paramN)
{
  //corpo proc.
}

Onde

param1..N: lista de parâmetros separados por vírgula
tipo_dado: tipo de dado do parâmetro
tipo_retorno: tipo de dado de retorno

Exemplo 4

using namespace std;

void funcao(int a, char b){
    cout<< a << endl;
    cout<< b << endl;
}

Saída

-

A passagem de argumentos para uma função é feita como na linguagem C, passamos o nomes das variáveis ou valores separados por (,).

Sintaxe

funcao(argumento1, argumento2, argumentoN);

Exemplo 5

#include <iostream>

using namespace std;

void funcao(int a, char b){
    cout<< a << endl;
    cout<< b << endl;
}
int main()
{
    funcao(1,'Z');
    return 0;
}

Saída

1 'Z'

Em C++, funções também pode ser passadas como argumento. Esse assunto pode ser visto com mais detalhes em C++ Básico: Ponteiro.

O assunto passagem de argumento por referência e valor foram vistos em Portugol: Passagem de Argumentos e em C Funções: Passagem por Valor e Referência.

Em C++, a passagem de argumentos por valor e referência é feita de forma semelhante à C. Utilizamos o tipo de dado reference(&) que informa que o parâmetro irá receber um valor por referência.

Quando não usamos (&) na declaração de nossos parâmetros, estamos informando que o argumento será passado como valor.

Exemplo 5

#include <iostream>
using namespace std;

void funcao1(int v1){
    v1 = 999; //alteração apenas em v1 interno
}

void funcao2(int &v1){
    v1 = 999;
}

int main()
{
    int v1 = 888; 
    cout << v1 << endl;
    funcao1(v1); //passando por valor
    cout << v1 << endl;
    
    cout << v1 << endl;   
    funcao2(v1); //passando por referência
    cout << v1<< endl;
    return 0;
}

Saída

888
888
888
999

Quando usamos a palavra reservada static na declaração de uma variável local de uma função, estamos informado que essa variável estará disponível para todas as chamadas da função.

Sintaxe

static tipo_dado nome_variavel = <valor>;

No exemplo a seguir, declaramos uma variável local que é incrementada e exibida na saída padrão(stdout). Seu conteúdo é incrementado nas três chamadas dessa função.

Exemplo 6

#include <iostream>
using namespace std;

void funcao()
{
    static int var = 0;
    var++;
    cout << var << endl;
}

int main()
{
    funcao();
    funcao();
    funcao();

    return 0;
}

Saída

1
2
3

Uso da palavra reservada auto na declaração de variáveis também pode ser aplicada ao retorno de uma função. O tipo de dado de retorno é deduzido baseado na expressão ou valor de retorno.

Sintaxe

auto nome_funcao(<parametros>)
{
  return valor_expressao;
}

No exemplo seguinte, uma função é declarada como auto para seu tipo de retorno. O comando return nessa função retorna um valor baseado em uma expressão. Como resultado, o retorno da função será definido como double, pois um valor inteiro multiplicado por um double resultará em um double.

Exemplo 7

#include <iostream>
using namespace std;

auto funcao(int a) {
    
    return a*0.1; //double
}

int main()
{
    auto ret = funcao(100);
    cout << typeid(ret).name() <<endl; //double
    cout << ret <<endl;
    return 0;
}

Saída

1
2
3

[C++ 20] A palavra reservada auto também pode ser utilizada em parâmetros de funções e métodos. O tipo de dado do parâmetro é inferido com base no valor passado como argumento para a função.

No exemplo abaixo, declaramos uma função em que o último parâmetro utiliza a keyword auto fazendo com que o comando return retorne um valor baseado no tipo de dado influenciado por uma expressão que envolve esse parâmetro.

Exemplo 8

#include <iostream>
using namespace std;

auto funcao(int a, auto b) 
{
    return a*b; //tipo de retorno baseado na expressão
}

int main()
{
    auto ret = funcao(100,0.1);
    cout << typeid(ret).name() <<endl; //double
    cout << ret <<endl <<endl;
    
    ret = funcao(100,2);
    cout << typeid(ret).name() <<endl; //int
    cout << ret <<endl;
    return 0;
}

Saída

d
10

i
200

C++ possui a suporte à sobrecarga de função. Com esse suporte, declaramos funções homônimas com quantidade de parâmetros e tipos de dados de retorno declarados com tipagem diferente.

Sintaxe

tipo_retorno nome_funcao(<parametros>); //protótipo

No exemplo abaixo, uma função tem seu único parâmetro, declarado como tipo int, sobrecarregado com o tipo bool. O argumento passado para função faz a distinção de qual sobrecarga será usada.

Exemplo 9

#include <iostream>
void funcao(int a)
{
    cout << hex << a << endl;
}

void funcao(bool a)
{
    cout << boolalpha << a << endl;
}

int main() 
{
    funcao(100);
    funcao(true);
}

Saída

64
true

No exemplo logo abaixo, uma função, que retorna o resultado de uma adição entre dois parâmetros, tem seus parâmetros int sobrecarregados com os tipos float e string. Os argumentos passado para função irão distinguir qual sobrecarga será usada.

Exemplo 10

#include <iostream>
using namespace std;

int funcao(int a, int b)
{
    return a + b;
}

float funcao(float a, float b)
{
    return a + b;
}

string funcao(string a, string b)
{
    return a + b;
}

int main() 
{
    cout << funcao(1,1) << endl;
    cout << funcao(1.1f,1.1f) << endl;
    cout << funcao("string ","concatenada") << endl;
}

Saída

d2
2.2
string concatenada

C++ também permite que a sobrecarga seja feita com diferentes quantidades de parâmetros. No exemplo abaixo sobrecarregamos a mesma função de adição adicionando mais uma parâmetro na sobrecarga para valores float.

Exemplo 11

#include <iostream>
using namespace std;

using namespace std;

int funcao(int a, int b)
{
    return a + b;
}

float funcao(float a, float b, float c)
{
    return a + b + c;
}

int main() 
{
    cout << funcao(1,1) << endl;
    cout << funcao(1.1f,1.1f, 1.1f) << endl;

}

Saída

2
3.3

Funções e métodos C++ permitem que parâmetros tenham um valor default informado ou declarado. Esses são vistos como opcionais sendo declarados sempre como últimos parâmetros.

Sintaxe

tipo_retorno nome_funcao(tipo_dado p1 = v1, tipo_dado p2 = v2, …); //protótipo

tipo_retorno nome_funcao(tipo_dado p1 = v1, tipo_dado p2 = v2, …) //declaração
{
   //corpo omitido
}

A declaração dos parâmetros com valor default deve ser feita apenas uma única vez, ou no protótipo da função ou declaração da função.

Exemplo 12: protótipo

#include <iostream>
using namespace std;

void funcao(int x = 1); //protótipo com valor default

int main()
{
    funcao(777);
    funcao();
    return 0;
}

//declaração sem valor default
void funcao(int a)
{
    cout << a << endl;
}

Saída

777
1

Exemplo 13: declaração

#include <iostream>
using namespace std;

//declaração com valor default
void funcao(int a = 1)
{
    cout << a << endl;
}

int main()
{
    funcao(777);
    funcao();
    return 0;
}

Saída

d2
2.2
string concatenada

Quando parâmetros com valor default são declarados em sobrecargas de funções, esses parâmetros devem ter seus valores informados em todas as sobrecargas.

Exemplo 14: valor default

#include <iostream>
#include <string>
using namespace std;

int funcao(int a = 1, int b = 1)
{
    return a + b;
}

float funcao(float a = 1.1, float b=1.1)
{
    return a + b;
}

string funcao(string a = "uma ", string b="string")
{
    return a + b;
}

int main() 
{
    cout << funcao(1,1) << endl;
    cout << funcao(1.1f,1.1f) << endl;
    cout << funcao("string ","concatenada") << endl;
}

Saída

2
2.2

A palavra reservada inline quanto aplicada a uma função em C++ informa ao compilador que o corpo da função deve ser inserido no local onde a função foi chamada.

inline é utilizado para diminuir o uso de recurso de memória e tempo ao invocar a função. Dependendo da situação, o overhead pode ser maior do que a execução da função.

Exemplo 15

#include <iostream>
using namespace std;

inline void funcao(auto a, auto b) 
{ 
    cout << a << b << endl;
}

int main()
{
    funcao(1,2); //cout << a << b << endl

    return 0;
}

Saída

12

O retorno de múltiplos valores em C++ pode ser feito utilizando ponteiros ou tipos de dados complexos/derivados como arrays, objetos, tuplas, structs e outros.

Exemplo 16: ponteiro

#include <iostream>
using namespace std;

int funcao(int* ret, int b) 
{ 
    *ret = b*3; //retorno 1 via ponteiro
    return b*2; //retorno 2 via return
}

int main()
{
    int ret;
    
    cout << funcao(&ret, 2) << endl; //usa ret para retorno
    cout << ret << endl;
    return 0;
}

Saída

4
6

Exemplo 17: struct

#include <iostream>
using namespace std;

struct m_struct {
    int a;
    int b;
};

struct m_struct funcao(int a, int b) 
{ 
    struct m_struct ret;
    ret.a = a*2;
    ret.b = a*3;
    
    return ret;
}

int main()
{
    int var_a = 10;
    int ret;
    
    struct m_struct ms = funcao(var_a, 2);
    cout << ms.a << endl;
    cout << ms.b << endl;
    
    return 0;
}

Saída

20
30

Exemplo 18: tuple

#include <iostream>
#include 

using namespace std;

tuple<int,bool> funcao(int a, int b) 
{ 
    if( a > b)
        return {a, true}; //tuple
        
    return {b,false};
}

int main()
{
    tuple<int,bool> ret = funcao(1, 2);
    //auto [a,b] = ret;
    cout << std::get<0>(ret) << endl; //campo 1
    cout << boolalpha << std::get<1>(ret) << endl; //campo 2
    
    return 0;
}

Saída

2
false

1. 13/07/2026 - revisão 7 - Ajustes: pontuais
2. 11/06/2026 - revisão 6 - Adição: 'Função inline' e 'Retornando múltiplos valores'
3. 19/11/2025 - revisão 5 - Adição: variável local, retorno com auto, sobrecarga e parâmetro com valor padrão
4. 28/07/2025 - revisão 4 - ajustes pontuais e em sintaxes
5. 30/09/2024 - revisão 3 - Remoção de intro 'Funções'; Correções e ajustes pontuais
6. 30/08/2024 - revisão 2 - Correção em links de objetivos
7. 09/02/2024 - revisão 1 - correção em navegação, css, exemplos e erros gramaticais
8. 30/06/2023 - versão inicial