Procedimentos em C++, como em C, são "funçoes" que não retornam nenhum tipo de valor ao término de sua execução. A palavra reservada void é utilizada informação 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 procedimentos, retornam um valor durante a sua execução. Qualquer tipo de dado dentre os já estudados pode ser utilizado como retorno além dos tipos fornecidos pela biblioteca padrão 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 muito complexos.

Para a passagem de argumentos para funções em C++, semelhante a 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 referencia 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 seguem as mesmas regras da linguagem 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 desse função.

Sintaxe

static tipo_dado nome_variavel = <valor>;

No exemplo que segue, declaramos uma variável local que é incrementada e exibida na saída padrão. 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

A partir de 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 a 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

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