Programa = Algoritmo + Estrutura de Dados

A todo momento durante a execução de

qualquer tipo de programa os computadores
estão manipulando informações, representadas
pelos diferentes tipos de dados, armazenadas
em sua memória.
Classificação dos tipos de dados
• Tipos de Dados Simples
– Tipos de Dados Inteiros: int, long e unsigned int
– Tipos de Dados Reais: float e double
– Tipos de Dados Caracteres: char
• Tipos de Dados Estruturados
– cadeia de caracteres (string), vetores (array), registros
(struct) e ficheiros em disco.
• ponteiros (alocação dinâmica de memória)
• Classes e Objetos (Orientação a Objetos)
Tipos de Dados Simples
Uma variável simples é uma entidade criada
para permitir o acesso a uma posição de
memória onde se armazena uma informação de
um determinado tipo de dado pela simples
referência a um nome simbólico.

i = 0;
int i, j, n; j = 5;
n = 50;

Memória Principal

i j n
0 5 50
Utilizando variáveis de Tipos de Dados Simples:

#include "stdio.h"

void main() {
int nota0 = 80;
int nota1 = 70;
int nota2 = 90;
int nota3 = 85;
int nota4 = 100;

printf("nota0 = %d\n", nota0);

printf("nota1 = %d\n", nota1);
printf("nota2 = %d\n", nota2);
printf("nota3 = %d\n", nota3);
printf("nota4 = %d\n", nota4);
}
Tipos de Dados Estruturados
• armazenam diversos itens de uma só vez

• isto significa:
– em uma mesma estrutura de dados, é possível
ter diversas variáveis de tipos de dados simples
agrupadas
Utilizando variáveis de Tipos de Dados
Estruturados:

#include "stdio.h"

void main() {

// declarando e alimentando o vetor

int nota[5] = {80, 70, 90, 85, 100};

// percorrendo todos os valores

// armazenados no vetor
for ( i=0; i<5; i++)
{
printf("nota[%i] = %i\n", i, nota[i]);
}
Vetores 1/3
• representa um conjunto de valores do mesmo tipo
(estrutura homogênea), referenciáveis pelo
mesmo nome e individualizados entre si através de
sua posição dentro desse conjunto (variáveis
indexadas)
• uma sequência de endereçamentos (posicoes
contíguas) de memória para armazenar os
conteúdos de suas diversas posições dentro do
vetor
• sinônimos: variáveis indexadas, variáveis
compostas, variáveis subscritas, arranjos, matrizes
(unidimensionais), tabelas em memória ou arrays.
Vetores 2/3
Vetores são estruturas de dados que armazenam usualmente uma
quantidade fixa de dados de um certo tipo; por esta razão,
também são conhecidos como estruturas homogêneas de dados.

Internamente, um vetor armazena diversos valores, cada um

associado a um número que se refere à posição de
armazenamento, e é conhecido como índice. Os vetores são
estruturas indexadas, em que cada valor que pode ser
armazenado em uma certa posição (índice) é chamado de
elemento do vetor.

Cada elemento do vetor pode ser utilizado individualmente de

forma direta, ou seja, pode ser lido ou escrito diretamente, sem
nenhuma regra ou ordem preestabelecida, fazendo dos vetores
estruturas de dados de acesso aleatório.
Vetores 3/3
O número de posições de um vetor corresponde ao tamanho que
ele tem; assim, um vetor de tamanho 10 tem esse número de
elementos, isto é, pode armazenar até dez elementos distintos. Os
diferentes elementos de um vetor são distinguidos unicamente
pela posição que ocupam no vetor. Cada posição de um vetor é
unicamente identificada por um valor inteiro positivo, linear e
sequencialmente numerado. Ou seja:
vetor[i] “i-ésimo” elemento do vetor, sendo que o valor da
variável “i” deve pertencer ao intervalo do índice
do vetor, ou seja, 0  i  (n-1)

As linguagens C e C++ como o Java são linguagens com vetores

zero-based, isto é, as posições do vetor iniciam a numeração a
partir do valor “0”, portanto, um vetor de tamanho 10 teria
índices iniciados em 0 prosseguindo até o 9.
Vetores ou Variáveis Indexadas
• O termo indexada provém da maneira como
é feita a individualização dos elementos do
conjunto de dados: por meio de índices.
• Uma variável indexada pode ser definida
como tendo um ou mais índices.
– vetor, um único índice (unidimensionais)
– matriz, dois índices (bidimensionais)
– multidimensionais, pouco freqüentes
Em Síntese: Características Básicas
• estrutura de dados homogênea e indexada

• todos os elementos da estrutura são igualmente

acessíveis
– tempo e tipo de procedimento para acessar qualquer um
dos elementos do vetor são “iguais”

• cada elemento componente deste tipo de estrutura

de dados tem um nome próprio que é o nome do
vetor seguido da posição, ou índice
NomeDaVariávelVetor[ posição, ou índice ]
Declarando Variáveis do Tipo Vetor
Na declaração de vetores deverão ser fornecidas três informações:
(1) o nome do vetor, (2) o número de posições do vetor (seu
tamanho) e (3) o tipo de dado que será armazenado no vetor.

A declaração de um vetor para “inteiros”, de nome “vetor” e

tamanho igual a 10, em C:

const n = 10; // tamanho do vetor

int vetor[n]; // declaração do vetor

Podemos notar que as declarações de vetores são semelhantes às

declarações de variáveis, os elementos sintáticos que diferenciam
as variáveis do tipo vetor das outras variáveis são os colchetes.
Declaração de vetores ou variáveis indexadas:

const n = 100;
float salarios[n];

int a[10], b[10]; // declaração compacta

Nos exemplos acima temos:

a e b, são conjuntos de 10 componentes
inteiros cada, ou seja, variáveis
capazes de armazenar 10 números
inteiros simultaneamente;

salarios, com capacidade de armazenar um total

de n (100) números reais;
vetores, individualizando valores:

x [ expressão ]

onde:
x nome da variável do tipo vetor

expressão posição que define qual o elemento

da estrutura de dados está sendo
referenciado. Atenção: deve ser um
valor pertencente ao intervalo do
índice da variável.

Observação: Os elementos de um vetor tem todas

as características de uma variável comum e podem
aparecer livremente em expressões e atribuições.

vetor[10] = vetor[1] * vetor[i + j];

Compreendendo o armazenamento de um vetor:
void main() {

const n = 10;
int a[n];

a[0] = 17; a[5] = 10;

a[1] = 33; a[6] = 45;
a[2] = 21; a[7] = 29;
a[3] = 67; a[8] = 79;
a[4] = 81; a[9] = 98;
} a[?]

0 1 2 3 4 5 6 7 8 9

17 33 21 67 81 10 45 29 79 98
Operações básicas com vetores ou array’s:

Do mesmo modo que acontece com variáveis simples, também é

possível realizar operações de atribuição (=), leitura (scanf)
e escrita (printf) com variáveis indexadas. Contudo, não é
possível operar diretamente com o conjunto completo, mas com
cada um de seus elementos isoladamente.

Por exemplo, para somar dois vetores é necessário somar cada

um de seus componentes dois a dois. Da mesma forma, as
operações de atribuição, leitura e escrita de conjuntos devem
ser feitas elemento a elemento.

sendo, int a[10], b[10], c[10];

Certo: Errado:
for (int i=0; i<10; i++) c = a + b;
c[i] = a[i] + b[i];

for (int i=0; i<10; i++) scanf("%d", &a);

scanf("%d", &a[i]);

for (int i=0; i<10; i++) printf("%d", a);

printf("%d\n", a[i]);
Atribuição (=)
No caso de variáveis indexadas, além do nome da
variável deve-se necessariamente fornecer também
o(s) índice(s) que individualizam o elemento do
conjunto onde será armazenado o resultado da
avaliação da expressão.

NomeDaVariávelVetor[posição] = Expressão;

void main() {
int nota[5];
nota[0] = 80;
nota[1] = 70;
nota[2] = 90;
nota[3] = 85;
nota[4] = 100;
...
}
Leitura
A leitura de um conjunto é feita passo a passo,
um componente por vez, usando a mesma sintaxe da
instrução primitiva de entrada de dados (scanf).
Mais uma vez, além do nome do conjunto, deve ser
explicitada a posição do elemento no vetor que
receberá o valor lido.

#include "stdio.h"
void main() {
int nota[5];
int i ;
for (i=0; i<5; i++) {
printf("\nInforme o valor da %i a. Nota:", i);
scanf("%i", &nota[i]);
}
... // processo de saída ou escrita
}
Escrita
A escrita de um conjunto obedece à mesma sintaxe
da instrução primitiva de saída de dados
(printf). Mais uma vez, convém lembrar que,
além do nome do conjunto, deve-se também
especificar por meio de seu(s) índice(s) qual o
elemento do vetor será escrito.

#include "stdio.h"

void main() {
int nota[5];

... // processo de entrada ou leitura

for (i=0; i<5; i++)
printf("\nNota %i- %i", i, nota[i]);
}
Printf(“a nota 3 e %i”,nota[2])
Procedimentos auxiliares
#include "stdlib.h"

• randomize();
– inicializa, ou prepara, a semente do gerador de
números aleatórios
• random(n);
– neste caso, o gerador de números aleatórios
sorteia um número inteiro aleatoriamente entre
0 e n-1
// Gerar aleatoriamente 8 elementos para uma matriz A
// tipo vetor. Construir uma matriz B de mesma dimensão
// com os elementos da matriz A multiplicados por 2.
#include "stdio.h"
declaração da estrtura de
#include "stdlib.h"
dados, vetores “a” e “b”
void main() { entrada- gera nros aleatórios
const n = 8; para armazenar no vetor
int i, a[n], b[n];
processamento- percorre o
randomize(); vetor realizando algum
for (i=0; i<n; i++) tipo de processamento
a[i] = random(10); com os itens armazenados

for (i=0; i<n; i++) saída- imprime os elementos

b[i] = a[i] * 2; armazenados no vetor

printf("i- a[i] b[i] = a[i] * 2\n");

printf("-------------------------\n");
for (i=0; i<n; i++)
printf("%d- %d %d\n", i, a[i], b[i]);
}
Contadores- quantificar coisas:
VariavelContador = VariavelContador + 1; ou
VariavelContador++;

#include "stdio.h"
#include "stdlib.h"
void main() {
const n = 10; // tamanho do vetor
int i; // índice ou posição
int a[n]; // declaração do vetor "a"
randomize();
for (i=0; i<n; i++) {
a[i] = random(50);
}

int ct = 0; // declaração e inicialização do contador

for (i=0; i<n; i++) {
// verifica "se" o i-ésimo item do vetor é menor que 10
if (a[i] < 10)
ct = ct + 1;
}

for (i=0; i<n; i++) {

if (a[i] < 10)
printf("a[%d] = %2d <=== menor que 10\n", i, a[i]);
else
printf("a[%d] = %2d\n", i, a[i]);
}
// exibe o resultado
printf("\n\nExistem %d itens no vetor menores que 10.", ct);
}
Somatórios- somar coisas:
VariavelSomatorio = VariavelSomatorio + ValorSomado; ou
VariavelSomatorio += ValorSomado;

#include "stdio.h"
#include "stdlib.h"
void main() {
const n = 10; // tamanho do vetor
int i; // índice ou posição
int a[n]; // declaração do vetor "a"
randomize();
for (i=0; i<n; i++) {
a[i] = random(50);
}

int sm = 0; // declaração e inicialização do somatório

for (i=0; i<n; i++) {
// verifica "se" o i-ésimo item do vetor é par
if ((a[i] % 2) == 0)
sm = sm + a[i];
}

for (i=0; i<n; i++) {

if ((a[i] % 2) == 0)
printf("a[%d] = %2d <=== par\n", i, a[i]);
else
printf("a[%d] = %2d\n", i, a[i]);
}
// exibe o resultado
printf("\n\nSoma dos pares = %d", sm);
}
Médias- calcular médias:
Salário médio dos funcionário do sexo masculino
Idade média dos alunos da disciplina de algoritmos
média = soma / quantidade de valores;

#include "stdio.h"
#include "stdlib.h"
void main() {
const n = 10; // tamanho do vetor
int i; // índice ou posição
int a[n]; // declaração do vetor "a"
randomize();
for (i=0; i<n; i++) {
a[i] = random(50);
}

int sm = 0, ct = 0; // declara e inicializa as variáveis

float media = 0;
for (i=0; i<n; i++) {
// verifica "se" o i-ésimo item do vetor é par
if ((a[i] % 2) == 0) {
sm = sm + a[i]; // soma os pares
ct = ct + 1; // conta os pares
media = float(sm) / ct; // calcula a média dos nros pares
printf("a[%d] = %2d <=== %do. par\n", i, a[i], ct);
}
else
printf("a[%d] = %2d\n", i, a[i]);
}

// exibe os resultados
printf("\n\nSoma dos pares = %3d\n", sm);
printf("Qtd. de pares = %3d\n", ct);
printf("Média dos pares = %6.2f", media);
}
Percentuais- calcular valores percentuais:
% de funcionários do sexo masculino
% de números pares
percentual = (valor parcial / valor total) * 100;

#include "stdio.h"
#include "stdlib.h"
void main() {
const n = 10; // tamanho do vetor
int i; // índice ou posição
int a[n]; // declaração do vetor "a"
randomize();
for (i=0; i<n; i++) {
a[i] = random(50);
}

int ct = 0; // declara e inicializa as variáveis

float p = 0;
for (i=0; i<n; i++) {
// verifica "se" o i-ésimo item do vetor é par
if ((a[i] % 2) == 0) {
ct = ct + 1; // conta os pares
p = (float(ct) / n) * 100; // calcula o percentual de nros pares
printf("a[%d] = %2d <=== %do. par\n", i, a[i], ct);
}
else
printf("a[%d] = %2d\n", i, a[i]);
}

// exibe o resultado
printf("\n\nExistem %d pares, ou seja, %.2f%%\n", ct, p);
}
Aplicações com Vetores
• Classificação, organizar um conjunto de
elementos em uma determinada ordem
(alfabética, numérica ou cronológica)
– Método da Bolha, mais popular
• Pesquisa, verificar a existência de um valor
dentro de um conjunto
– Método de Pesquisa Sequencial
– Método de Pesquisa Binária
Ordenação por Troca (Método da Bolha)

A filosofia básica deste método consiste em:

1. "Varrer" o vetor, comparando os elementos vizinhos
entre si: if (a[j] > a[j+1]).

2. Caso estejam fora de ordem, os mesmos trocam de

posição entre si (swap).

3. Procede-se assim até o final do vetor. Na primeira

"varredura" verifica-se que o último elemento do vetor
já está no seu devido lugar (no caso de ordenação
crescente, ele é o maior de todos).A segunda
"varredura" é análoga à primeira e vai até o
penúltimo elemento.

4. Este processo é repetido até que seja feito um número

de varreduras igual ao número de elementos a serem
ordenados menos um. Ao final do processo o vetor está
classificado segundo o critério escolhido.
#include "stdio.h"
#include "stdlib.h"
void main() {
// declaração da estrutura de dados
const n = 10;
int i, j, a[n];
// entrada- gerar nros aleatórios para armazenar no vetor
randomize();
for (i=0; i<n; i++)
a[i] = random(10);
// processamento: ordenação usando o método da bolha (Buble Sort)
int aux; 4
for (i=1; i<=(n-1); i++)
for (j=0; j<(n-i); j++)
3
if (a[j] > a[j+1]) {
1 aux = a[j]; // swap: troca dois elementos de posição
a[j] = a[j+1]; 2
a[j+1] = aux;
}
// saída- imprime os resultados
printf("i- Vetor Ordenado\n");
for (i=0; i<n; i++)
printf("%d- %8d\n", i, a[i]);
}
Ordenação por Seleção
Um dos algoritmos mais simples de ordenação. Neste método a
classificação é efetivada por seleção sucessiva do menor valor
de chave contido no vetor "a". A cada passo é feita uma
varredura do segmento do vetor com os elementos ainda não
selecionados e determinado aquele elemento de menor valor, o
qual é colocado, por troca, em sua posição definitiva no vetor
classificado e o processo repetido para o segmento que contém
os elementos ainda não selecionados.

Na Prática
1º passo: procura a posição do menor elemento do vetor (min)
e em seguida realiza a troca deste elemento com
aquele que está na primeira posição (a[i]);

2º passo: procura o menor elemento no subvetor que começa a

partir da segunda posição e troca com o segundo
elemento e assim por diante;

O método deverá repetir sucessivamente o processo de seleção

durante "n-1" passos.
#include "stdio.h"
#include "stdlib.h"
void main() {
// entrada- declaração do vetor e gera nros aleatórios
const n = 10;
int aux, i, j, min, a[n];
randomize();
for (i=0; i<n; i++)
a[i] = random(10);
// processamento: ordenação por seleção (Selection Sort)
for (i=0; i<(n-1); i++) {
min = i;
for (j=(i+1); j<n; j++)
if (a[j] < a[min])
min = j; // min = posição do menor elemento
aux = a[i]; // swap: troca dois elementos de posição
a[i] = a[min];
a[min] = aux;
}
// saída- imprime os resultados
printf("i- Vetor Ordenado\n");
for (i=0; i<n; i++)
printf("%d- %8d\n", i, a[i]);
}
Método de Pesquisa Sequencial
A pesquisa seqüencial ou linear é o método mais
objetivo para se encontrar um elemento
particular em um conjunto não classificado.

Esta técnica consiste:

1. na simples verificação de cada componente do
conjunto sequencialmente, uma após a outra
2. até que o elemento desejado seja encontrado,
neste caso, diz-se que a pesquisa foi bem
sucedida
3. ou que todos os elementos do conjunto tenham
sido verificados sem que o elemento procurado
tenha sido encontrado, pesquisa malsucedida.
void main() {
...
int x;
printf("Informe o valor a ser procurado no vetor: ");
scanf("%d", &x);

// processamento: Método de Pesquisa Sequencial

int encontrou = 0; // flag, 0- pesquisa “mal” sucedida

// 1- pesquisa “bem” sucedida
int p = 0;
1 while ((p < n) && (encontrou == 0))
if (a[p] == x)
encontrou = 1; 2 // o elemento foi encontrado
else
p = p + 1;

...

if (encontrou == 0)
printf("%d não está armazenado no vetor.\n", x);
else
printf("%d está armazenado na posição %d.\n", x, p); 3
}
Método de Pesquisa Binária
Quando os elementos de um vetor estão previamente
classificados segundo algum critério, então pesquisas
muito mais eficientes podem ser conduzidas. Entre estas
destaca-se o método de pesquisa binária.
Esta técnica consiste:
1. inicialmente o vetor é classificado
2. o elemento que divide o vetor ao meio com relação ao
seu número de componentes é localizado e comparado ao
valor procurado.
3. Se ele for igual ao valor procurado a pesquisa é dita
bem-sucedida e é interrompida.
4. no caso dele ser maior que o valor procurado, repete-se
o processo na primeira metade do vetor.
5. no caso do elemento central do vetor ser menor que o
valor procurado, repete-se o processo na segunda metade
do vetor.
6. Este procedimento é continuado até que o elemento
desejado seja localizado (pesquisa bem-sucedida), ou
então, até que não reste mais nenhum trecho do vetor
a ser pesquisado (pesquisa malsucedida).
void main() {
... // classificar o vetor 1
int x;
printf("Informe o valor a ser procurado no vetor: ");
scanf("%d", &x);
// processamento: Método de Pesquisa Binária
int encontrou = 0; // flag, 0- pesquisa “mal” sucedida
// 1- pesquisa “bem” sucedida
int meio, inicio = 0, fim = (n – 1);
while ((inicio <= fim) && (encontrou == 0)) { 6
meio = (inicio + fim) / 2;
2 if (a[meio] == x)
encontrou = 1; 3 // o elemento foi encontrado
else
if (a[meio] > x)
fim = meio – 1; 4 // primeira metade do vetor
else
inicio = meio + 1; 5 // segunda metade do vetor
}
if (encontrou == 0)
printf("%d não está armazenado no vetor.\n", x);
else
printf("%d está armazenado na posição %d.\n", x, meio);
}
Vetores Bidimensionais, ou Matrizes
C suporta vetores multidimensionais. A forma mais simples de
vetor multidimensional é o vetor bidimensional, ou matriz (Ai,j).
– tabela de linhas e colunas
– armazenam vetores dentro de vetores

Por exemplo, para declarar um vetor bidimensional de inteiros

denominado “matriz” de tamanho 2 x 4, ou seja, 2 linhas por
4 colunas, deve-se escrever o seguinte código:

int matriz[2][4];

Atenção: Muitas linguagens de programação usam vírgulas para

separar as dimensões do vetor multidimensional; C, em contraste,
coloca cada dimensão no seu próprio conjunto de parenteses retos.
Declarando um vetor bidimensional, ou matriz
int A[2][4];

Referenciando as posições da matriz

1a. Linha 2a. Linha
------------- -------------
A[0][0] = 17; A[1][0] = 13;
A[0][1] = 33; A[1][1] = 81;
A[0][2] = 21; A[1][2] = 97;
A[0][3] = 15; A[1][3] = 67;
0 1 2 3 j, coluna
0 17 33 21 15
A[i][j]
1 13 81 97 67

i, linha
Lendo e escrenvendo um vetor bidimensional, ou matriz
A leitura de um conjunto bidimensional é feita, como nos vetores
unidimensionais, passo a passo, um componente por vez, usando a
mesma sintaxe das instruções primitivas de entrada (scanf) e
saída (printf) informando o nome da matriz as posições da linha
e da coluna como mostra o exemplo a seguir:
#include "stdio.h"
#include "conio.h"

void main() {
const n = 3;
int matriz[n][n], i, j;
for (i=0; i<n; i++)
for (j=0; j<n; j++) {
printf("Informe o valor da linha %d, coluna %d.\n", i, j);
scanf("%d", &matriz[i][j]);
}
system(“cls”);
for (i=0; i<n; i++) {
for (j=0; j<n; j++)
printf("%4d ", matriz[i][j]);
printf("\n");
}
}
Inicialização de Vetores
C permite a inicialização de vetores no momento da declaração,
como é demonstrado nos exemplos a seguir:

int vetor[10] = {17, 33, 21, 67, 81, 10, 45, 29, 79, 98};

isso significa que vetor[0] terá o valor 17 e vetor[9] terá o valor 98

int matriz[2][4] = {17, 33, 21, 15,

13, 81, 97, 67};

nos vetores bidimensionais os valores são inicializados por linha,

no exemplo, matriz[1][2] (segunda linha e terceira coluna) terá o
valor 97
Vetor de Strings
Para criar um vetor de strings, usa-se uma matriz bidimensional
de caracteres. Na declaração o tamanho do índice esquerdo indica
o número de strings e o “tamanho do índice direito especifica o
comprimento máximo de cada string”.
#include "stdio.h"

void main() {

char nomeMes[12][3] = {"jan", "fev", "mar", "abr", "mai",

"jun", "jul", "ago", "set", "out", "nov", "dez"};

for (int i=0; i<12; i++) {

printf("%2d-", (i+1));

for (int j=0; j<3; j++)

printf("%c", nomeMes[i][j]);

printf("\n");
}
}
Vetores Multidimensionais
C permite vetores com mais de duas dimensões. O limite exato, se
existe, é determinado pelo compilador usado.

A forma geral da declaração de um vetor multidimensional segue

a seguinte sintaxe:

tipo nome[Tamanho1][Tamanho2][Tamanho3]...[TamanhoN];

por exemplo, int x[2][2][4]; onde “x” representa uma estrutura de

dados com 2 * 2 * 4 = 16 números inteiros, indexados da seguinte
forma:
x[0][0][0] x[0][1][0] x[1][0][0] x[1][1][0]
x[0][0][1] x[0][1][1] x[1][0][1] x[1][1][1]
x[0][0][2] x[0][1][2] x[1][0][2] x[1][1][2]
x[0][0][3] x[0][1][3] x[1][0][3] x[1][1][3]
Conceitos sobre Matrizes

• Matriz quadrada
– número de linhas igual ao número de colunas
• Diagonal principal
– Ai,j para todo i == j
• Diagonal secundária
– Ai,j para todo (i + j) == (n - 1)

• Matriz esparsa
– a maioria dos elementos da matriz é zero
Exemplo de Matriz Quadrada
const n = 4;
int A[n][n] = {17, 33, 21, 15, 13, 81, 97, 67,
13, 31, 24, 5, 3, 8, 92, 63};

i, linha
0 1 2 3 j, coluna
A[i][j] 0 17 33 21 15
1 13 81 97 67
2 13 31 24 5
3 3 8 92 63

diagonal secundária [(i+j)==(n-1)]: diagonal principal (i==j):

A[0][3] 15 A[0][0] 17
A[1][2] 97 A[1][1] 81
A[2][1] 31 A[2][2] 24
A[3][0] 3 A[3][3] 63
// Dado um vetor A de duas dimensões com 4 linhas e 4 colunas. Elaborar um programa que
// calcule e escreva o valor da soma dos elementos deste vetor, ou matriz.

#include "stdio.h" Alimentando a matriz por linha:

#include "stdlib.h"
#include "conio.h"
i:0, 1, 2, 3,
j:0,1,2,3 0,1,2,3 0,1,2,3 0,1,2,3
void main() {
// declaração da estrutura de dados
const n = 4;
int A[n][n]; // matriz quadrada de n linhas x n colunas
int i, j, sm = 0;

// entrada- gerar nros aleatórios para armazenar no vetor bidimensional

randomize();
for (i=0; i<n; i++)
for (j=0; j<n; j++)
A[i][j] = random(10);

// processamento: somando todos os elementos da matriz

for (i=0; i<n; i++)
for (j=0; j<n; j++)
sm = sm + A[i][j];

// saída: imprime os resultados

clrscr();
printf("Matriz A\n");
printf("==============\n");
for (i=0; i<n; i++) {
for (j=0; j<n; j++)
printf("%2d ", A[i][j]);
printf("\n");
}

printf("\nA soma dos elementos da matriz é igual a %d", sm);

}
Referência
• C Completo e Total
– Herbert Schildt.
– São Paulo: MAKRON Books - 1996.