Retornando matriz

[viciado 1]

Eu tenho uma função para preencher matriz. Como eu faço essa função retornar a matriz ? Tipo:

 

int preenche(){
int m[2][2];
  .
  .	  // Aqui passos para preencher a matriz
  .
  .
return // Aqui eu gostaria de retornar a matriz
}

Eu posso fazer essa fução retornar matriz e depois em outra função criar uma matriz tipo:

 

int m[2][2] = preenche(); // Em outra função poder chamar a função preenche

[_Isis_ 202]

Retorne um int **.

[viciado 1]

Eu posso fazer isso ?

 

float preenche(){
	  int i,j,tam_l,tam_c;
	  printf("Informe a quantidade de linhas \n");
	  scanf("%d",&tam_l);
	  printf("Informe a quantidade de colunas \n");
	  scanf("%d",&tam_c);
	  float M[tam_l][tam_c];
	  for(i=0;i<tam_l;i++){
		  for(j=0;j<tam_c;j++){
					 printf("Preenche M[%d][%d] \n",i,j);
					 scanf("%f",&M[i][j]);
					 }
					 }
	  printf("Sua Matriz \n");
	  for(i=0;i<tam_l;i++){
		  for(j=0;j<tam_c;j++){
					 printf("M[i][j] = %d \n",i,j,M[i][j]);
									 }
									 } 
	  return **M;		
}
float soma(){
	  float M1 = preenche();
	  float M2 = preenche();

[_Isis_ 202]

Preste atenção nos tipos.

[viciado 1]

Como assim nos tipos ?

[_Isis_ 202]

Preste atenção no que você está fazendo!

[viciado 1]

Poderia explicar o que você q dizer ?

[José Enésio 4]

float M1 = preenche();

float preenche(){

 

float M[tam_l][tam_c];

 

return **M;

 

 

 

Retorne float**, declare uma variável float**, retorne float**.

 

Você não pode declarar M[] com um valor variável. Se quer uma array com tamanho variável, utilize alocação de memória e ponteiros:

 

float** M;

M = (float**)malloc(sizeof(int) * tam_l * tam_c);

[viciado 1]

Incompatible types in assigment, nas linhas 31 e 32

Na função soma ainda nao realizei a operação soma só que ver a matriz se está correta

 

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

int tam_l, tam_c;
float preenche(){
	  int i,j;
	  printf("Informe a quantidade de linhas \n");
	  scanf("%d",&tam_l);
	  printf("Informe a quantidade de colunas \n");
	  scanf("%d",&tam_c);
	  float M[tam_l][tam_c];
	  return **M;		
}
float soma(){
	  float** M1;
	  M1 = (float**)malloc(sizeof(int)* tam_l * tam_c);
	  float** M2;
	  M2 = (float**)malloc(sizeof(int)* tam_l * tam_c);
	  M1 = preenche();
	  M2 = preenche();
	  int i,j;
	  for(i=0;i<tam_l;i++){
		  for(j=0;j<tam_c;j++){
					 printf("M1[i][j] = %d \n",i,j,M1[i][j]);
					 }
					 }
	  for(i=0;i<tam_l;i++){
		  for(j=0;j<tam_c;j++){
					 printf("M2[i][j] = %d \n",i,j,M2[i][j]);
									  }
									  }	
}

int main()
{
  soma();
  system("PAUSE");	
  return 0;
}

[eibon 2]

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

int tam_l, tam_c;
void preenche(){
	  printf("Informe a quantidade de linhas \n");
	  scanf("%d",&tam_l);
	  printf("Informe a quantidade de colunas \n");
	  scanf("%d",&tam_c);
}

void soma(){
	  float** M1;
	  float** M2;
	  preenche();
	  M1 = (float**)malloc(sizeof(int)* tam_l * tam_c);
	  preenche();
	  M2 = (float**)malloc(sizeof(int)* tam_l * tam_c);
	  int i,j;
	  for(i=0;i<tam_l;i++){
		  for(j=0;j<tam_c;j++){
					 printf("M1[%d][%d] = %f \n",i,j,M1[i][j]);
					 }
					 }
	  for(i=0;i<tam_l;i++){
		  for(j=0;j<tam_c;j++){
					 printf("M2[%d][%d] = %f \n",i,j, M2[i][j]);
									  }
									  }
}

int main()
{
  soma();
  system("PAUSE");
  return 0;
}

Seu code tá feio pacas...e 'não faz nada'.Modifiquei só retirando os erros...se é que me entende.

Reveja isso ai.

 

Edit:

 

Ps: tem coisa errrada também...

[_Isis_ 202]

#include <stdio.h>
#include <stdlib.h>
void preenche(int **MATRIZ,int LINHAS, int COLUNAS) {
	int i,j;
	for(i=0;i<LINHAS;i++) {
			for(j=0;j<COLUNAS;j++)
					scanf("%d",&MATRIZ[i][j]);
	}
}


int main(int argc, char const* argv[])
{
	int LINHAS=2,COLUNAS=2;
	int **M = (int**)malloc(sizeof(int*)*LINHAS);
	int i;
	for(i=0;i<LINHAS;i++)
			M[i] = (int*)malloc(sizeof(int)*COLUNAS);

	preenche(M,LINHAS,COLUNAS);
	int j;
	for(i=0;i<LINHAS;i++) {
			for(j=0;j<COLUNAS;j++)
					printf("%d ",M[i][j]);
			puts("");
	}
	free(M);
	M=NULL;
	return 0;
}

[viciado 1]

Eu não entendi o que você fez. A minha dúvida é tendo uma função para preencher matriz, como em outra função criar variaveis e atribuir a função que preencher para criar a matriz a essa variavel.

[_Isis_ 202]

Eu não entendi o que você fez.

 

Uso básico de ponteiros. Se não está entendendo, volte p/ o livro.

 

 

como em outra função criar variaveis e atribuir a função que preencher para criar a matriz a essa variavel.

 

Explique direito, porque a dúvida no começo era essa:

 

Eu tenho uma função para preencher matriz. Como eu faço essa função retornar a matriz ?

 

Supondo que você quer retornar a matriz numa função que modifica o estado dela, já que estou trabalhando com ponteiros, não preciso retornar a matriz porque a alteração é feita 'in-place'. Deduza o resto.

[viciado 1]

Vou tentar explicar melhor.

Quero fazer uma função para preencher a matriz. Nessa função o usuario informa o numero de linhas, colunas e os elementos da matriz.

Depois em outras funções quero criar varivel e fazer essa varivel ser uma matriz preenchida pela função que irar preencher a matriz.

 

float preenche(){
	   .
	   .	   /* Criar e Preencher a matriz */
	   .
}

float func(){
	   float M;
	   M = preenche();  /* Fazer M ser uma matriz */
	   .
	   .						/* Operações que eu desejo fazer como: somar, multiplicar.... */
	   .
}

Eu gostaria de saber como fazer isso.

[quitZAUMMM 18]

calma ai M n tem q ser uma matriz?

cria ela como global vai, assim você n vai se complicar com o tipo de retorno.

 

[]s

[_Isis_ 202]

Quero fazer uma função para preencher a matriz. Nessa função o usuario informa o numero de linhas, colunas e os elementos da matriz.

Depois em outras funções quero criar varivel e fazer essa varivel ser uma matriz preenchida pela função que irar preencher a matriz.

 

Pelo jeito você não executou o código que eu postei...

Função que preenche qualquer coisa não deveria se preocupar em ler coisas que não são problemas dela.

 

 

 

cria ela como global vai, assim você n vai se complicar com o tipo de retorno.

 

Não. Ele tem que aprender a usar tipo de retorno e ponteiro nem que seja se matando.

[viciado 1]

O que você quis dizer com

 

"Função que preenche qualquer coisa não deveria se preocupar em ler coisas que não são problemas dela."

[eibon 2]

#include <stdio.h>

#include <stdlib.h>

 

float *getFP(int cols);

float **getFPP(int rows, int cols);

void menu(int *rows, int *cols);

void preencheFP(float *fp, int fpsize);

void preencheFPP(float **fp, int fpD1size, int fpD2size);

void printFP(float *fp, int fpsize);

void printFPP(float **fpp, int fpD1size, int fpD2size);

 

 

int main()

{

int rows,cols;

float **fpp;

menu(&rows, &cols);

fpp = getFPP(rows, cols);

preencheFPP(fpp, rows, cols);

puts("fpp");

printFPP(fpp, rows, cols);

return 0;

}

 

float *getFP(int cols){

return (float*)(malloc(sizeof(float)*cols));

}

 

float **getFPP(int rows, int cols){

float **fpp = (float**)(malloc(sizeof(float*)*sizeof(rows)));

int it;

for(it = 0;it < cols;it++)

fpp[it] = getFP(cols);

return fpp;

}

 

void menu(int *rows, int *cols){

printf("Digite o numero de rows:");

scanf("%d", rows);

printf("Digite o numero de colunas:");

scanf("%d", cols);

puts("-------");

}

 

void preencheFP(float *fp, int fpsize){

int it;

for(it = 0;it < fpsize;it++){

fp[it] = (it+1.5)*550.75;

}

}

 

void preencheFPP(float **fp, int fpD1size, int fpD2size){

int it;

for(it = 0;it < fpD1size;it++){

preencheFP(fp[it], fpD2size);

}

}

 

void printFP(float *fp, int fpsize){

int it;

for(it = 0;it < fpsize;it++){

printf("\t[%d] = %.3f\n", it, fp[it]);

}

}

 

void printFPP(float **fpp, int fpD1size, int fpD2size){

int it;

for(it = 0;it < fpD1size;it++){

printf("[%d] = \n", it);

printFP(fpp[it], fpD2size);

}

}

[viciado 1]

Aqui um exemplo do que eu queria fazer. Estou tendo erro nos ponteiros

 

 

 

#include <stdio.h>
#include <stdlib.h>
float soma(float *M1, float *M2, int linhas_1, int linhas_2, int colunas_1, int colunas_2){
  float M3[linhas_1][colunas_1];
  int i,j;
  if(linhas_1 == linhas_2 && colunas_1 == colunas_2){
			  for(i=0;i<linhas_1;i++){
					   for(j=0;j<colunas_1;j++){
								 M3[i][j] = M1[i][j] + M2[i][j];
								 }
								 }
			  return M3;		   
			  }
  else {
	   return 0;
	   }
}
int main()
{
  int linhas_1, linhas_2, colunas_1, colunas_2;
  printf("Quantas linhas tem a primeira matriz ? \n");
  scanf("%d",&linhas_1);
  printf("Quantas colunas tem a primeira matroz ? \n");
  scanf("%d",&colunas_1);
  int i, j;
  float M1[linhas_1][colunas_1];
  for(i=0;i<linhas_1;i++){
		   for(j=0;j<colunas_1;j++){
							printf("Preenche matriz: M1[%d][%d] \n",i,j);
							scanf("%f",&M1[i][j]);
							}
							}
  printf("Quantas linhas tem a segunda matriz ? \n");
  scanf("%d",&linhas_2);
  printf("Quantas colunas tem a segunda matroz ? \n");
  scanf("%d",&colunas_2);
  float M2[linhas_2][colunas_2];
  for(i=0;i<linhas_1;i++){
		   for(j=0;j<colunas_1;j++){
							printf("Preenche matriz: M2[%d][%d] \n",i,j);
							scanf("%f",&M2[i][j]);
							}
							}
  soma(M1, M2, linhas_1, linhas_2, colunas_1, colunas_2);
  system("PAUSE");	
  return 0;
}

[_Isis_ 202]

isis@linux-ytxp:~/src/Imasters> gcc matriz1.c -Wall -Wextra

matriz1.c: In function ‘soma’:

matriz1.c:9: error: subscripted value is neither array nor pointer

matriz1.c:9: error: subscripted value is neither array nor pointer

matriz1.c:12: error: incompatible types in return

matriz1.c:17: warning: control reaches end of non-void function

matriz1.c: In function ‘main’:

matriz1.c:44: warning: passing argument 1 of ‘soma’ from incompatible pointer type

matriz1.c:44: warning: passing argument 2 of ‘soma’ from incompatible pointer type

 

De novo: PRESTE ATENÇÂO NO QUE VOCÊ ESTÁ FAZENDO!!!!!!!!

Leia o diabo da mensagem que o compilador cospe na tela e tente arrumar. Sim, eu já estou passada com gente que posta o código e diz "não compila", "dá erro", "não faz o que eu quero" e não se dá ao trabalho de ler as mensagens do compilador.

Se o IDE não diz nada, troque de IDE ou configure p/ mostrar.