Ponteiros com matrizes bidimensionais em C

Assuntos Gerais
#1

galera quero passar matrizes como argumento e retornar uma outra matriz com base no processamento dos argumentos
consegui dessa forma mais não ta funcionando corretamente quando imprima os valores retornados.

to postando um exemplo de soma de matrizes.

pesso a vc que dei uma olhado.

pesso sugestoes maneiras melhores de fazer isso.

#include <stdio.h>
#include <stdlib.h>


int* soma(int linha, int coluna, int *mat1, int *mat2) {
     
     int i = 0, j = 0, *soma[linha][coluna];
     
     for( i = 0 ;i < linha; i++) {
           for( j = 0; j < coluna; j++) {
                 soma[i][j] = *mat1++ + *mat2++; 
                 printf("%d\n",soma[i][j]);     
           }
     }
     
     return soma;
}

int main(int argc, char *argv[])
{
  int *n[2][3], i = 0;
  
  n[0][0] = 2;
  n[0][1] = 3;
  n[0][2] = 4;
  
  n[1][0] = 2;
  n[1][1] = 4;
  n[1][2] = 5;
   
  int *c = soma(2,3,&n,&n);
  for( i = 0 ; i < 6; i++) {
       printf("\n%d",c[i]);
  }
  
  system("PAUSE");	
  return 0;
}
#2

cara… os argumentos que você está passando para a função está errada… vc está mandando duas matrizes e está recebendo um vetor…

outra coisa… lembre-se que uma matriz ou vetor já é um ponteiro… a única diferença é que eles já alocam os espaços na memória quando vc declara…

tira a matriz como ponteiro e na função os dois últimos inteiros vc coloca **

tira o ‘&’ da matriz também

#3

não entendi bem o que vc disse

"tira a matriz como ponteiro e na função os dois últimos inteiros vc coloca ** ".

pode exemplificar:

#4

não entendi o que vc quer fazer, mas uma matriz, ou vc cria normal do jeito convencional: matriz[][] ou utilizando ponteiros vc vai ter **matriz

:wink:

*isso_pode_ser_um_vetor
**isso_pode_ser_uma_matriz

#5

se quiser dar uma olhada, uma vez eu fiz uns posts num blog abandonado com exercicios da faculdade com isso:

#6

cara fiz o que ralphsilver pediu e tabem dei uma olhada nos links que o ceb10n passou e fiz o sequinte no codigo, que compila mas não roda:

#include <stdio.h>
#include <stdlib.h>


int** soma(int linha, int coluna, int **mat1, int **mat2) {
     
     int i = 0, j = 0, count = 0, **soma[linha][coluna];
     
     for( i = 0 ;i < linha; i++) {
           for( j = 0; j < coluna; j++) {
                 **soma[i][j] = **mat1++ + **mat2++; 
                 printf("%d\n",soma[i][j]);     
           }
     }
     
     return soma;
}

int main(int argc, char *argv[])
{
  int n[2][3], i = 0;
  
  n[0][0] = 2;
  n[0][1] = 3;
  n[0][2] = 4;
  
  n[1][0] = 2;
  n[1][1] = 4;
  n[1][2] = 5;
   
  int **c = soma(2,3,n,n);
  for( i = 0 ; i < 6; i++) {
       printf("\n%d",c[i]);
  }
  
  system("PAUSE");	
  return 0;
}

cara como não entedese bem o que falei no primeiro topico, entam vou explicar novamente.

quero fazer o sequinte: preciso passar uma ou varias matrizes para uma função e retornar uma matrizes como resultado da execução da função.
no exemplo que mostrei passo duas matrizes e retorno uma matriz com a soma das matrizes passadas como argumento.

#7

Uma variável do tipo int n[2][3] não é do tipo int**. Lembre-se, C não é Java, e matrizes bidimensionais em C não são implementadas como ponteiros para ponteiros.

Na verdade, matrizes bidimensionais em C são mais ou menos implementadas como matrizes bidimensionais em Fortran (ou seja, como blocos contínuos em memória, que são indexados via multiplicações e adições), exceto que no caso do Fortran a ordem física dos dados em memória é por colunas, e então por linhas, e no caso do C a ordem é por linhas, depois colunas.

Ela é do tipo int[2][3].

Estranho, não?

Essa é uma das coisas que tornam difíceis a manipulação de matrizes em C. Na prática, quando se quer usar matrizes bidimensionais em C, ou você define as matrizes com todas as dimensões constantes, exceto a última (ou a primeira, nunca lembro qual delas), ou então você mesmo cria uma macro que faz a indexação adequada para a posição em um vetor que simula a sua matriz multidimensional.

#8

Vou dar um exemplo. Digamos que você declare a seguinte matriz em C:

int a[3][4];

Os elementos em memória são organizados assim:
0 - a[0][0]
1 - a[0][1]
2 - a[0][2]
3 - a[0][3]
4 - a[1][0]
5 - a[1][1]
6 - a[1][2]
7 - a[1][3]
8 - a[2][0]
9 - a[2][1]
10 - a[2][2]
11 - a[2][3]

Então, quando você quer definir uma matriz em C que tem número indeterminado de linhas e colunas, você na verdade deve definir um vetor unidimensional em C que tenha n * m elementos, e para indexar algo dentro dessa matriz, você pega o número da linha, multiplica pelo número de colunas (nesse caso 4), e soma com o número da coluna.

int a[3 * 4];
a [2 * 4 + 1]; // em vez de a[2][1]. Veja que 2 * 4 + 1 == 9.
OK?

#9

[quote=entanglement]Essa é uma das coisas que tornam difíceis a manipulação de matrizes em C. Na prática, quando se quer usar matrizes bidimensionais em C, ou você define as matrizes com todas as dimensões constantes, exceto a última (ou a primeira, nunca lembro qual delas), ou então você mesmo cria uma macro que faz a indexação adequada para a posição em um vetor que simula a sua matriz multidimensional.
[/quote]
Primeira.

#10

[quote=ajinfotec]

cara como não entedese bem o que falei no primeiro topico, entam vou explicar novamente.

quero fazer o sequinte: preciso passar uma ou varias matrizes para uma função e retornar uma matrizes como resultado da execução da função.
no exemplo que mostrei passo duas matrizes e retorno uma matriz com a soma das matrizes passadas como argumento.[/quote]

Veja se é isso que você pretendia:

[code]
#include <stdio.h>

#define LINHA 2
#define COLUNA 3

void
soma_matrizes(int linhas, int colunas, int mat_ret[LINHA][COLUNA], int mat1[LINHA][COLUNA], int mat2[LINHA][COLUNA])
{
int i;
int j;

for (i = 0; i < linhas; i++) {
	for (j = 0; j < colunas; j++) {
		mat_ret[i][j] = mat1[i][j] + mat2[i][j];
	}
}

}

int
main (int argc, char *argv[])
{
int i, j;

int matriz_ret[LINHA][COLUNA] = {
					   0,0,0,
					   0,0,0
					   };
int matriz1[LINHA][COLUNA] = {
					2,3,4,
					2,4,5
					};
int matriz2[LINHA][COLUNA] = {
					2,3,4,
					2,4,5
					};

printf("\nMatrizes\n");
printf("matriz_ret:\n");
for (i = 0; i < LINHA; i++)
	for (j = 0; j < COLUNA; j++)
		printf("[%d][%d] = %d\n", i, j, matriz_ret[i][j]);

printf("matriz1:\n");
for (i = 0; i < LINHA; i++)
	for (j = 0; j < COLUNA; j++)
		printf("[%d][%d] = %d\n", i, j, matriz1[i][j]);

printf("matriz2:\n");
for (i = 0; i < LINHA; i++)
	for (j = 0; j < COLUNA; j++)
		printf("[%d][%d] = %d\n", i, j, matriz2[i][j]);

printf("matriz_ret = matriz1 + matriz2\n");

soma_matrizes(LINHA, COLUNA, matriz_ret, matriz1, matriz2);

printf("matriz_ret:\n");
for (i = 0; i < LINHA; i++)
	for (j = 0; j < COLUNA; j++)
		printf("[%d][%d] = %d\n", i, j, matriz_ret[i][j]);

return 0;

}[/code]
Resultado:

Matrizes
matriz_ret:
[0][0] = 0
[0][1] = 0
[0][2] = 0
[1][0] = 0
[1][1] = 0
[1][2] = 0
matriz1:
[0][0] = 2
[0][1] = 3
[0][2] = 4
[1][0] = 2
[1][1] = 4
[1][2] = 5
matriz2:
[0][0] = 2
[0][1] = 3
[0][2] = 4
[1][0] = 2
[1][1] = 4
[1][2] = 5
matriz_ret = matriz1 + matriz2
matriz_ret:
[0][0] = 4
[0][1] = 6
[0][2] = 8
[1][0] = 4
[1][1] = 8
[1][2] = 10

Solução 2:

#include <stdio.h>

#define LINHA  2
#define COLUNA 3

void
soma_matrizes(int linhas, int colunas, int *p_mat_ret, int *p_mat1, int *p_mat2)
{
	int i;

	for (i = 0; i < (linhas * colunas); i++) {
			*(p_mat_ret + i) = *(p_mat1 + i) + *(p_mat2 + i);
	}
		
}

int
main (int argc, char *argv[])
{
	int i, j;

	int matriz_ret[LINHA][COLUNA] = {
						   0,0,0,
						   0,0,0
						   };
	int matriz1[LINHA][COLUNA] = {
						2,3,4,
						2,4,5
						};
	int matriz2[LINHA][COLUNA] = {
						2,3,4,
						2,4,5
						};
	
	printf("\nMatrizes\n");
	printf("matriz_ret:\n");
	for (i = 0; i < LINHA; i++)
		for (j = 0; j < COLUNA; j++)
			printf("[%d][%d] = %d\n", i, j, matriz_ret[i][j]);
	
	printf("matriz1:\n");
	for (i = 0; i < LINHA; i++)
		for (j = 0; j < COLUNA; j++)
			printf("[%d][%d] = %d\n", i, j, matriz1[i][j]);

	printf("matriz2:\n");
	for (i = 0; i < LINHA; i++)
		for (j = 0; j < COLUNA; j++)
			printf("[%d][%d] = %d\n", i, j, matriz2[i][j]);

	printf("matriz_ret = matriz1 + matriz2\n");

	soma_matrizes(LINHA, COLUNA, matriz_ret, matriz1, matriz2);

	printf("matriz_ret:\n");
	for (i = 0; i < LINHA; i++)
		for (j = 0; j < COLUNA; j++)
			printf("[%d][%d] = %d\n", i, j, matriz_ret[i][j]);

	return 0;
}

Resultado:

Matrizes
matriz_ret:
[0][0] = 0
[0][1] = 0
[0][2] = 0
[1][0] = 0
[1][1] = 0
[1][2] = 0
matriz1:
[0][0] = 2
[0][1] = 3
[0][2] = 4
[1][0] = 2
[1][1] = 4
[1][2] = 5
matriz2:
[0][0] = 2
[0][1] = 3
[0][2] = 4
[1][0] = 2
[1][1] = 4
[1][2] = 5
matriz_ret = matriz1 + matriz2
matriz_ret:
[0][0] = 4
[0][1] = 6
[0][2] = 8
[1][0] = 4
[1][1] = 8
[1][2] = 10

Se liga no que o entanglement te falou. Matriz, ponteiros e strings são muito próximos um do outro e é complicado entender as nuances entre eles.
Não vá escrevendo o programa todo de uma vez quando você não sabe o que está fazendo, monte-o aos poucos, escreva pequenos trechos de códigos para testar suas idéias, quando estiver em dúvida sobre como as coisas estão “indo” no seu programa use o printf(). Se liga no slide 35. 8)

LEIA: http://www.linuxmall.com.br/produto/livro-c-completo-e-total.html
http://www.linuxmall.com.br/produto/livro-c-a-linguagem-de-programacao-padrao-ansi.html

#11

galera fiz assim e ta funcionando.

#include <stdio.h>
#include <stdlib.h>

//AUTOR: JOSE ANTONIEL DE LIMA

int i,j;


void escreva(int linha, int coluna, int **saida) {

     for (i = 0; i < linha; i++) {
         printf("\n");
         for (j = 0; j < coluna; j++) {
             printf("%d ", saida[i][j]);
         }
     }
}


int ** aloque(int linha, int coluna) {
    
    int **retorno;
    
    retorno = (int **)malloc(sizeof(int)*linha);//aloca as linhas da matriz
    
    for(i = 0; i < linha; i++) {         
        retorno[i] = (int *)malloc(sizeof(int)*coluna);//aloca as colunas para cada linha da matriz          
    }
    
    return retorno;
}


int ** leia(int linha, int coluna) {
    
    int **entrada = aloque(linha,coluna);
    
    for (i = 0; i < linha; i++) {
        for (j = 0; j < coluna; j++) {
            printf("\nDigite a posicao [%d][%d] da matriz: ", i+1, j+1);
            scanf("%d", &entrada[i][j]);
        }
    }
    
    return entrada;
}


int ** soma(int linha, int coluna, int **mat1, int **mat2) {
     
     int **soma = aloque(linha,coluna);
     
     for( i = 0 ;i < linha; i++) {
           for( j = 0; j < coluna; j++) {
                 soma[i][j] = mat1[i][j] + mat2[i][j];   
           }
     }
     
     return soma;
}


int main(int argc, char *argv[]) {
    
  int  linha = 3, coluna = 3;
     
  //calcula a soma das matrizes lidas e retorna seu resultado
  int **c = soma(linha,coluna,leia(linha,coluna),leia(linha,coluna));
 
  escreva(linha,coluna,c);//escreve a matriz
    
  printf("\n\n");//imprime uma nova linha na saida
  
  system("PAUSE");	//pausa a aplicação
  
  return 0;//informa o sistema que tudo terminou bem
  
}

o que quero é passar matrizes como argumentos e retorna outra matriz independente de qual seja o exemplo
postei aqui o exemplo da soma somente para mostrar como fazia, porem não funcionava.

ai turma continuo pedindo opiniões melhores de como fazer isso, agora to usando uma função aloque(),
iai vcs conhecem uma forma melhor de fazer isso.

obrigado desde ja.

1 curtida
#12

Mas aí é que está. Eu andei lendo o código do ajinfotec e notei que essa fórmula/notação com ponteiros não é verdadeira para representar toda matriz em notação de matriz. Explico.

Na linha 41: scanf("%d", &entrada[i][j]); então posso concluir que essa matriz foi declarada assim int entrada[][] ? Vejamos…

Se:

matriz [n][m] == *( matriz + (n X MAX_m) + m )

então:
a linha 41 do código dele poderia ser escrita assim scanf("%d", entrada+(i*coluna)+j);

Só que se você fizer assim o código dele buga. O motivo é que essa notação em matriz (m[][]) esconde a matemática de ponteiros feita pelo compilador durante a análise do código.
No final das contas não se pode afirmar que uma matriz de inteiros multidimencional (“int matriz [n][m]”) é do tipo int [n][m] ou int ** pois você não sabe como os elementos da matriz foram alocados (Eu sei que no fundo são diferentes). Tanto é que o cálculo em ponteiros para a linha 41 do código do ajinfotec é: scanf("%d", (*(entrada+i)+j));

[b]
Daí que:

matriz [n][m] == *( matriz + (n X MAX_m) + m ) tal que, matriz seja alocada como um array unidimencional de tamanho n X m
matriz [n][m] == *( *( matriz + n ) + m ) tal que, matriz seja alocada como um array unidimencional, com tamanho n, de ponteiros para um array unidimencional de tamanho m
[/b]

Modo Debug das funcões do ajinfotec

void escreva(int linha, int coluna, int **saida) {

     for (i = 0; i < linha; i++) {
         printf("\n");
         for (j = 0; j < coluna; j++) {
             printf("(%p) %d - ",&saida[i][j], saida[i][j]);
         }
     }
}


int ** aloque(int linha, int coluna) {
    
    int **retorno;
    
    retorno = (int **)malloc(sizeof(int)*linha);//aloca as linhas da matriz
    printf("retorno: %p\n", retorno);

    for(i = 0; i < linha; i++) {         
        retorno[i] = (int *)malloc(sizeof(int)*coluna);//aloca as colunas para cada linha da matriz
	  printf("retorno[%d]: 0x%p [0x%p]\n", i, &retorno[i], retorno[i]);         
    }

    return retorno;
}


int ** leia(int linha, int coluna) {
    
    int **entrada = aloque(linha,coluna);
    
    for (i = 0; i < linha; i++) {
        for (j = 0; j < coluna; j++) {
            printf("\nDigite a posicao [%d][%d] da matriz: ", i+1, j+1);
            scanf("%d", &entrada[i][j]);

		/* Depuracao de interpretacao da sintaxe */
		printf("&entrada[i][j]: %p -|- (*(entrada+i)+j): %p -|- entrada+(i*coluna)+j: %p\n", &entrada[i][j], (*(entrada+i)+j), entrada+(i*coluna)+j);
        }
    }
    
    return entrada;
}

Região da memória onde são armazenadas as matrizes no Win XP 32 bits (vai que tem alguém realmente lendo esse tópico :slight_smile: e entendendo essa confusão toda :stuck_out_tongue: )

[b]mat 1
entrada (0x003D2478)

          0x003D2478  [ 0x003D2490 ] ---> 0x003D2490 [1], 0x003D2494 [1], 0x003D2498 [1] 
          0x003D247C [ 0x003D24A8 ] ---> 0x003D24A8 [2], 0x003D24AC [2], 0x003D24B0 [2]
          0x003D2480  [ 0x003D24C0 ] ---> 0x003D24C0 [3], 0x003D24C4 [3], 0x003D24C8 [3]

mat 2
entrada (0x003D24D8)

          0x003D24D8 [ 0x003D24F0 ] ---> 0x003D24F0 [1], 0x003D24F4 [1], 0x003D24F8 [1] 
          0x003D24DC [ 0x003D2508 ] ---> 0x003D2508 [2], 0x003D250C [2], 0x003D2510 [2]
          0x003D24E0 [ 0x003D2520 ] ---> 0x003D2520 [3], 0x003D2524 [3], 0x003D2528 [3]

soma
entrada (0x003D2538)

           0x003D2538 [ 0x003D2550 ] ---> 0x003D2550 [2], 0x003D2554 [2], 0x003D2558 [2] 
           0x003D253C [ 0x003D2568 ] ---> 0x003D2568 [4], 0x003D256C [4], 0x003D2570 [4]
           0x003D2540 [ 0x003D2580 ] ---> 0x003D2580 [6], 0x003D2584 [6], 0x003D2588 [6]

[/b]

#13

ei cara tambem executei no windows xp 32 bits e gerou essa saida.

to postando toda a saida da execução do programa.

cara ñ entendo a notação de matriz que voce postau, a um tempo venho lendo mas continuo não
entendendo.

se a algo erado com as posições de memoria da matriz, acho eu que deve ser por causa da função aloque(),
e ela quem estar alocando as posições de memoria da matriz.

[color=black]
retorno: 003E3888

retorno[0]: 0x003E3888 [0x003E48A8]
retorno[1]: 0x003E388C [0x003E48C0]
retorno[2]: 0x003E3890 [0x003E48D8]

Digite a posicao [1][1] da matriz: 1

&entrada[i][j]: 003E48A8 -|- ((entrada+i)+j): 003E48A8 -|- entrada+(icoluna)+j: 003E3888

Digite a posicao [1][2] da matriz: 2

&entrada[i][j]: 003E48AC -|- ((entrada+i)+j): 003E48AC -|- entrada+(icoluna)+j: 003E388C

Digite a posicao [1][3] da matriz: 4

&entrada[i][j]: 003E48B0 -|- ((entrada+i)+j): 003E48B0 -|- entrada+(icoluna)+j: 003E3890

Digite a posicao [2][1] da matriz: 7

&entrada[i][j]: 003E48C0 -|- ((entrada+i)+j): 003E48C0 -|- entrada+(icoluna)+j: 003E3894

Digite a posicao [2][2] da matriz: 8

&entrada[i][j]: 003E48C4 -|- ((entrada+i)+j): 003E48C4 -|- entrada+(icoluna)+j: 003E3898

Digite a posicao [2][3] da matriz: 9

&entrada[i][j]: 003E48C8 -|- ((entrada+i)+j): 003E48C8 -|- entrada+(icoluna)+j: 003E389C

Digite a posicao [3][1] da matriz: 6

&entrada[i][j]: 003E48D8 -|- ((entrada+i)+j): 003E48D8 -|- entrada+(icoluna)+j: 003E38A0

Digite a posicao [3][2] da matriz: 7

&entrada[i][j]: 003E48DC -|- ((entrada+i)+j): 003E48DC -|- entrada+(icoluna)+j: 003E38A4

Digite a posicao [3][3] da matriz: 5

&entrada[i][j]: 003E48E0 -|- ((entrada+i)+j): 003E48E0 -|- entrada+(icoluna)+j: 003E38A8

retorno: 003E48F0

retorno[0]: 0x003E48F0 [0x003E4908]
retorno[1]: 0x003E48F4 [0x003E4920]
retorno[2]: 0x003E48F8 [0x003E4938]

Digite a posicao [1][1] da matriz: 7

&entrada[i][j]: 003E4908 -|- ((entrada+i)+j): 003E4908 -|- entrada+(icoluna)+j: 003E48F0

Digite a posicao [1][2] da matriz: 8

&entrada[i][j]: 003E490C -|- ((entrada+i)+j): 003E490C -|- entrada+(icoluna)+j: 003E48F4

Digite a posicao [1][3] da matriz: 5

&entrada[i][j]: 003E4910 -|- ((entrada+i)+j): 003E4910 -|- entrada+(icoluna)+j: 003E48F8

Digite a posicao [2][1] da matriz: 6

&entrada[i][j]: 003E4920 -|- ((entrada+i)+j): 003E4920 -|- entrada+(icoluna)+j: 003E48FC

Digite a posicao [2][2] da matriz: 3

&entrada[i][j]: 003E4924 -|- ((entrada+i)+j): 003E4924 -|- entrada+(icoluna)+j: 003E4900

Digite a posicao [2][3] da matriz: 7

&entrada[i][j]: 003E4928 -|- ((entrada+i)+j): 003E4928 -|- entrada+(icoluna)+j: 003E4904

Digite a posicao [3][1] da matriz: 8

&entrada[i][j]: 003E4938 -|- ((entrada+i)+j): 003E4938 -|- entrada+(icoluna)+j: 003E4908

Digite a posicao [3][2] da matriz: 1

&entrada[i][j]: 003E493C -|- ((entrada+i)+j): 003E493C -|- entrada+(icoluna)+j: 003E490C

Digite a posicao [3][3] da matriz: 2

&entrada[i][j]: 003E4940 -|- ((entrada+i)+j): 003E4940 -|- entrada+(icoluna)+j: 003E4910

retorno: 003E4950
retorno[0]: 0x003E4950 [0x003E4968]
retorno[1]: 0x003E4954 [0x003E4980]
retorno[2]: 0x003E4958 [0x003E4998]

(003E4968) 8 - (003E496C) 10 - (003E4970) 9 -
(003E4980) 13 - (003E4984) 11 - (003E4988) 16 -
(003E4998) 14 - (003E499C) 8 - (003E49A0) 7 -

[/color]

#14

[quote=ajinfotec]ei cara tambem executei no windows xp 32 bits e gerou essa saida.

to postando toda a saida da execução do programa.

cara ñ entendo a notação de matriz que voce postau, a um tempo venho lendo mas continuo não
entendendo.
[/quote]
Nunca tinha visto essas relações entre matrizes e ponteiros assim “tão de perto” mas uma notação pode ser substituida pela outra assim:

#include <stdio.h>

int
main (int argc, char *argv[])
{
	int i;
	int mat[4] = { 0, 1, 2 ,3 };
	for ( i = 0; i < 4; i++) {
		printf("mat[%d]: %d == *(mat+%d): %d\n", i, mat[i], i, *(mat+i));
	}
	for ( i = 0; i < 4; i++) {
		printf("&mat[%d]: %p == (mat+%d): %p\n", i, &mat[i], i, (mat+i));
	}
return 0;
}

Saída:
mat[0]: 0 == *(mat+0): 0
mat[1]: 1 == *(mat+1): 1
mat[2]: 2 == *(mat+2): 2
mat[3]: 3 == *(mat+3): 3
&mat[0]: 0022FF88 == (mat+0): 0022FF88
&mat[1]: 0022FF8C == (mat+1): 0022FF8C
&mat[2]: 0022FF90 == (mat+2): 0022FF90
&mat[3]: 0022FF94 == (mat+3): 0022FF94

Não tem nada de errado, foi só seu windows que alocou em outra região, mesmo os 2 sendo xp 32 bits. O porque eu não sei.

Vou continuar fazendo uns testes sobre essa questão de ponteiro e matrizes e vou postando aqui.
Qual compilador você está usando?

#15

uso o dev-c++

o dev-c++ usa o gcc como compilador

#16

Só para vocês ficarem espertos. Quando um programa roda, você não tem uma maneira muito razoável de determinar onde é que uma região de memória vai ser alocada com o método “malloc” (como vocês estão usando). Você pode ter um programa compilado com o mesmo compilador e mesma versão, que em diversas máquinas mostre resultados diferentes, apenas por que a biblioteca de runtime do Microsoft C (MSVCRT.DLL ou coisa parecida) está em versão diferente. É por isso que os endereços aparecem sempre diferentes. E pode até ser que, se você rodar um mesmo programa na mesma máquina em instantes diferentes, os tais endereços apareçam diferentes, devido a alguma incerteza que possa ocorrer durante a execução. Os tais endereços servem apenas como referência e só são significativos dentro de uma determinada execução de um determinado programa em uma determinada máquina usando uma determinada versão do sistema operacional.

#17