Uma matriz é um vetor de duas dimensões que armazena seus dados de forma sequencial em memória. Seus elementos são acessados por suas linhas de linhas e colunas. Uma matriz quadrada com as dimensões 3x3 pode ser representada na forma abaixo:

Tab. 1: Abstração de matriz de int

L/C	0	1	2
0	10	20	30
1	40	50	60
2	70	80	90

A declaração de uma matriz estática na linguagem C++ é feita utilizando um tipo de dado deseja para uma variável e suas dimensões utilizando o operador [].

Sintaxe

tipo_dado nome_matriz[<linhas>][<colunas>] = {valores}; //iniciada
tipo_dado nome_matriz[<linhas>][<colunas>];             //espaço reservado
tipo_dado nome_matriz[<linhas>][<colunas>] = {0};       //todos elementos zerados

Uma matriz com valores iniciados devem ter seus valores delimitados por { e }, separados por (,) e terminados com (;). Os valores para cadas linhas devem ser delimitados por { e }, separados por (,). Uma vez declarada, suas dimensões não pode ser mais alteradas.

Exemplo 1

#include <stdio.h>

int main()
{
    int vet1[][2] = {{1,2},{3,4}}; //tamanho baseado em elementos atribuídos
    int vet2[2][2] = {{1,2},{3,4}}; //tamanho predefinido
    int vet3[2][2]; //espaço reservado
    int vet4[2][2] = {0}; //todos elementos iniciados com 0

    return 0;
}

A linguagem C++, diferente de C, permite que uma matriz seja iniciada quando suas dimensões são baseadas em variáveis.

Sintaxe

tipo_dado nome_matriz[var_linhas][var_colunas] = {valores};
tipo_dado nome_matriz[var_linhas][var_colunas];

Exemplo 2

#include <stdio.h>

int main()
{
    int i=2,j=2;
    int vet1[i][j] = {{1,2},{3,4}};
    int vet3[i][j]; //espaço reservado
    int vet4[i][j] = {0}; //todos elementos iniciado com 0

    return 0;
}

Todos os tipos de dados podem ser utilizados para criação de vetores como char, float , struct, string e outros tipos de dados nativos.

O acesso aos elementos de uma matriz é feita utilizando as suas linhas e colunas, como referência, que são passados como argumentos para o indexado [].

Sintaxe: alteração

nome_matriz[linha][coluna] = valor; 

Sintaxe: acesso

nome_matriz[linha][coluna]; //acesso;

Exemplo 3

#include <stdio.h>

int main()
{
    int vetor[2][2] ={{1,2},{3,4}};
    
    vetor[0][0] = 1;
    vetor[1][0] = 2;
    
    cout << vetor[1][0] << endl;

    return 0;
}

Para iterarmos ou percorrermos matrizes em C++, assim como em C, podemos utilizar o comando for que foi estudado em C++ Básico: Comandos for.

Quando trabalhamos com matrizes, precisamos de duas variáveis auxiliares que servirão utilizas para armazenar suas linhas e colunas.

Exemplo 4

#include <iostream>
using namespace std;

int main ()
{
  int matriz[2][2] = {{-1,9},{235,10}};
  int linha,coluna;

  for (linha = 0; linha < 2; linha++)
  {
        for (coluna = 0; coluna < 2; coluna++)
        {
            cout << matriz[linha][coluna] << " ";
        }
        cout << "\n";
  }
  return 0;
}

Saída

-1 9 
235 10

O tamanho de uma matriz pode ser calculado utilizando o operador sizeof que será visto visto mais adiante.

Para copiarmos o conteúdo matrizes, acessamos seus elementos e copiamos para uma nova matriz. O comando for aprendido em C++ Básico: Comandos de repetição será utilizado.

Quando trabalhamos com vetor, precisamos de uma variável auxiliar que servirá como índice para ambos os vetores como índice de origem e destino para cópia do elemento.

Exemplo 5

#include <iostream>
using namespace std;

int main()
{
  int o[2][2] = {{1,2},{3,4}};
  int d[2][2] = {0};
   
  int i,j;
  for(i = 0 ; i < 2 ; i++){
    for(j = 0 ; j < 2 ; j++){
      d[i][j] = o[i][j];
    }    
  }

  for(i = 0 ; i < 2 ; i++){
    for(j = 0 ; j < 2 ; j++){
      cout << d[i][j];
    }  
    cout << endl;
  }
  return 0;
}

Saída

12
34

Outras formas para copiar matrizes serão vistas em futuras atualizações.

Matrizes estáticas armazenam certas quantidades de elementos. Esses elementos possuem um tamanho em bytes em memória. Levando isso em consideração, não podemos confundir a quantidade de elementos com o tamanho da matriz.

Exemplo 6

int matriz[2][2] = {{-1,9},{235,10}}; 

No exemplo acima temos um matriz de int com uma capacidade de armazenamento de 4 elementos. Porém, cada elemento possui o tamanho de 4 bytes. Assim podemos calcular o tamanho de um vetor como sendo:

Fórmula 1

tamanho = numero_elementos*tamanho_tipo_dado

Para descobrirmos os tamanho em bytes de um matriz, utilizamos o operador sizeof que pode receber como argumento um vetor.

Exemplo 7

#include <iostream>
using namespace std;
int main()
{
    int matriz[2][2] = {{-1,9},{235,10}}; 
    cout << sizeof(matriz);
    return 0;
}

Saída

16

Como uma matriz é um vetor de duas dimensões, precisamos realizar algunas cálculos para descobrir suas quantidades de linhas e colunas usando o operador sizeof.

Fórmula 2

sizeof(matriz[0]);                //tamanho em bytes da linha

sizeof(matriz)/sizeof(matriz[0]); //número de linhas

sizeof(matriz[0])/sizeof(int);    // número de colunas 

Exemplo 8

#include <iostream>
using namespace std;

int main()
{
    int matriz[2][3];

    cout << sizeof(matriz) << endl;
    cout << sizeof(matriz)/sizeof(int)<< endl;
    cout << sizeof(matriz[0])<< endl;
    cout << sizeof(matriz)/sizeof(matriz[0])<< endl;
    cout << sizeof(matriz[0])/sizeof(int)<< endl;
    return 0;
}

Saída

24
6
12
2
3

Para a utilização de matrizes como parâmetro, seguimos a mesma idéia que foi vista para vetores: declaramos um parâmetro como matriz e outros dois parâmetros contendo suas dimensões.

Sintaxe A:

tipo_retorno nome_funcao( tipo_dado var_matriz[][num_colunas], int num_linhas, int num_colunas);

Sintaxe B:

nome_funcao(matriz, num_linhas, num_colunas); 

As sintaxe A e B acima mostram a declaração de um protótipo de uma função e a passagem de uma matriz como argumento respectivamente.

Exemplo 9

#include <iostream>
using namespace std;

//[2] obrigatório
void funcao(int v[][2], int l,int c)
{
    //uso de l e c aqui
    cout << v[0][0] <<endl;
}
int main() {
 
    int vt[2][2] = {{999,1},
                    {2,3}};
    
    funcao(vt,2,2);
    return 0;
}

Saída

999

A linguagem C++, assim como C, não permite que a referência de uma matriz local seja retorna de uma função. Precisamos declarar a variável matriz como sendo static. Além do uso de static, precisamos declarar o retorno de uma função como um ponteiro para um array.

Sintaxe

tipo_retorno (*nome_funcao(<lista_parametros>))[dimensao] //protótipo

Exemplo 10

#include <iostream>
using namespace std;

int(*funcao(void))[2]
{  
    static int v[2][2] = {{1,2},{3,4}};
    return v;
}

int main()
{
  int (*matriz)[2] = funcao();
  cout << matriz[0][0];
  cout << matriz[0][1];
  cout << matriz[1][0];
  cout << matriz[1][1];
  return 0;
}

Saída

1234

Como a linguagem C++ não armazena informação sobre as dimensões de matrizes estáticos é necessário ter conhecimento dessas informações para trabalhar com o tipo de dado matriz. Outras formas para retornar matriz em funções serão vistas nas próximas atualizações.

1. 28/07/2025 - revisão 3 - Correções: pontuais, 'Objetivos', numeração de exemplos; Ajuste:sintaxes; Adição de ex.1 e 2
2. 30/09/2024 - revisão 2 - Correções: Ex. 3; Austes gramaticais pontuais
3. 09/02/2024 - revisão 1 - correção em navegação, css, exemplos e erros gramaticais
4. 30/06/2023 - versão inicial