Ir para conteúdo

Arquivado

Este tópico foi arquivado e está fechado para novas respostas.

eacpaula

Passagem de Matrizes de String por Referência e Valor

Recommended Posts

Como passar uma matriz por referência e valor em linguagem de programação C?

 

como a estrutura do protótipo da função vai ficar?

 

Exemplo.:

 

Tenho uma matriz bidimensional para receber dados do tipo string como segue abaixo:

 

#include <stdio.h>

#include <stdlib.h>

 

//prototipos

 

int inclusao (char *produtos);

 

int main(){

char produtos[1000][100];

 

printf("DIGITE A DESCRICAO: \n");

scanf("%s",produto);
getchar();
inclusao(&produtos);

}

 

Obs.:

* Sei que a forma como estruturei está errada, porém, não encontrei muita coisa na web que especifique a forma como quero fazer.

* Sei que em passagem de vetores e matrizes por referência neste formato, somente o primeiro índice da matriz vai ser passado para a função de la o restante é tranquilo, mas, o problema em si é como realmente funciona a passagem por referência de uma matriz para dar sequencia nela e trabalhar com ela a partir de outras funções, sem ter que passagem por valor em que se copia todo o conteúdo da matriz e passa para a função?

Compartilhar este post


Link para o post
Compartilhar em outros sites

A rigor, C não possui passagem por referência, apenas por valor.

O lance dos ponteiros como argumento é que é passado um endereço de memória por valor e vc utiliza ele p/ acessar o objeto real.

Compartilhar este post


Link para o post
Compartilhar em outros sites

Primeiramente agradeço muito a atenção e o post de forma rápida!

 

Certo, a compreensão do que é passagem por referência que em "C" é feita com ponteiros, que passa o endereço de memória de um objeto compreendi o conceito.

 

Acontece, que não consegui estender este conceito aplicando em matrizes, não sei como referenciar o endereço da memoria da matriz em uma função.

 

Teria algum exemplo pratico e simples que não mostre um sistema ou um algoritmo comprido o objetivo é só ver como referenciar o ponteiro da matriz em uma função e também se possível colocar um protótipo da função com ela referenciada, também, algo bem pratico.

 

Se for possível exemplificar num exemplo da passagem de uma matriz para uma função qualquer e se de preferência ela for do tipo char, vai ajudar bastante.

Compartilhar este post


Link para o post
Compartilhar em outros sites
Quando se declara como array:



#include <stdio.h>

void multiplica(int m[][3], int a) {
for(int i = 0; i<3; i++) {
for(int j=0; j<3; j++) {
m[i][j] = m[i][j] * a;
}
}
}

void imprime(int m[][3]) {
for(int i=0; i<3; i++) {
for(int j=0; j<3; j++) {
printf("%d%c",m[i][j], (j==2)?'\n':' ');
}
}
}
int main(void) {
int m[3][3] = {{1,2,3},{4,5,6},{7,8,9}};
imprime(m);
puts("");
multiplica(m, 2);
imprime(m);
return 0;
}


Se você tentar escrever as funções utilizando a sintaxe de ponteiros, vai se deparar com alguns warnings e erros:



isis@linux:~/src/imasters> gcc-5 -Wall -Wextra -std=c99 matriz.c

matriz.c: In function ‘main’:

matriz.c:19:10: warning: passing argument 1 of ‘imprime’ from incompatible pointer type [-Wincompatible-pointer-types]

imprime(m);

^

matriz.c:10:6: note: expected ‘int **’ but argument is of type ‘int (*)[3]’

void imprime(int ** m) {

^

matriz.c:21:13: warning: passing argument 1 of ‘multiplica’ from incompatible pointer type [-Wincompatible-pointer-types]

multiplica(m, 2);

^

matriz.c:2:6: note: expected ‘int **’ but argument is of type ‘int (*)[3]’

void multiplica(int ** m, int a) {

^

matriz.c:22:10: warning: passing argument 1 of ‘imprime’ from incompatible pointer type [-Wincompatible-pointer-types]

imprime(m);

^

matriz.c:10:6: note: expected ‘int **’ but argument is of type ‘int (*)[3]’

void imprime(int ** m) {

^


isis@linux:~/src/imasters> gcc-5 -Wall -Wextra -std=c99 matriz.c

matriz.c: In function ‘main’:

matriz.c:19:10: warning: passing argument 1 of ‘imprime’ from incompatible pointer type [-Wincompatible-pointer-types]

imprime(&m);

^

matriz.c:10:6: note: expected ‘int **’ but argument is of type ‘int (*)[3][3]’

void imprime(int ** m) {

^

matriz.c:21:13: warning: passing argument 1 of ‘multiplica’ from incompatible pointer type [-Wincompatible-pointer-types]

multiplica(&m, 2);

^

matriz.c:2:6: note: expected ‘int **’ but argument is of type ‘int (*)[3][3]’

void multiplica(int ** m, int a) {

^

matriz.c:22:10: warning: passing argument 1 of ‘imprime’ from incompatible pointer type [-Wincompatible-pointer-types]

imprime(&m);

^

matriz.c:10:6: note: expected ‘int **’ but argument is of type ‘int (*)[3][3]’

void imprime(int ** m) {

^


A coisa muda quando você utiliza alocação dinâmica (por praticidade não fiz as verificações dos retornos do malloc e nem liberei os ponteiros,mas na vida real você deve fazer essas coisas):



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

void multiplica(int ** m, int a) {
for(int i = 0; i<3; i++) {
for(int j=0; j<3; j++) {
m[i][j] = m[i][j] * a;
}
}
}

void imprime(int ** m) {
for(int i=0; i<3; i++) {
for(int j=0; j<3; j++) {
printf("%d%c",m[i][j], (j==2)?'\n':' ');
}
}
}

int main(void) {
int ** m = malloc(sizeof(int *) * 3);
int i,j;
for(i=0; i<3; i++) {
m[i] = malloc(sizeof(int)*3);
for(j=0; j<3; j++) {
m[i][j] = (i+2)*(j+3);
}
}

imprime(m);
puts("");
multiplica(m, 2);
imprime(m);
return 0;
}


Entenda bem o conceito de ponteiro, porque a parte filé da coisa não é ficar fazendo lista ligada. É usar ponteiro p/ funções como callback e criar funções com lista de argumentos variáveis:




Compartilhar este post


Link para o post
Compartilhar em outros sites

Boa Tarde _Isis_!

Novamente, muito obrigado pela atenção!

Estive estudando sobre ponteiros nos últimos dias, mas, a passagem de matrizes para funções ainda tem me assombrado, ainda estou com dificuldade de trabalhar com este tipo de conteúdo.

Tenho um código aqui estava desenvolvendo como exemplo e testando algumas situações.

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


void listar(char nomes[][10], int t);

int main(){
	int j, i, k=1, l;
	char nomes[10][10], capturaChar;
	
	for(j=0;j<=10;j++){
		for(i=0;i<=10;i++){
			printf("Digite o nome %d: \n",k);
			
			//EXEMPLO DE COLETA DE CARACTERES DO TECLADO
			do {
				capturaChar = getchar();
				nomes[j][l] = capturaChar;
				l++;
			}while(capturaChar != '\n');
			k++;
		}
	}
	
	//TESTE COM PONTEIROS
		/* char *ponteiroNomes[10][10];
		ponteiroNomes = &nomes[0][0];*/
	
	//PASSANDO ENDERECO DE MEMORIA E QUANTIDADE DE LINHAS
	//listar(&nomes[0][0],10);
	listar(nomes,10);
	
	system("cls");
	system("pause");
}

void listar(char nomes[][10], int t){
	int i, j;
	
	for(j=0;j<=10;j++){
		for(i=0;i<=10;i++){
			printf("%s",nomes[j][i]);
		}
	}
}

Como podes visualizar, estava testando algumas formas de passagem e métodos de captura de dados do usuário.

 

Então vamos as dúvidas:

* Em pesquisas vi algumas relações para passagem de matrizes bidimensionais:

 

protótipo para passagem de matriz bidimensional, no código desenvolvido acima está da seguinte maneira:

 

void listar(char nomes[][10], int t);

 

como ficaria o protótipo do mesmo, se utilizasse um ponteiro que indicaria a posição de memoria inicial da minha matriz bidimensional?

 

Pelo que pude entender das pesquisas, no protótipo da função, posso não indicar a quantidade de linhas como opção, e obrigatoriamente tenho que indicar o tamanho/quantidade de colunas, a variável do lado com o nome de "T" ficaria subentendida como sendo a quantidade de linhas que a mesma possui, isto seria uma passagem por valor, copiando a matriz inteira para a função.

 

Isto, pelo que entendi de alguns materiais pesquisas, seria assim mesmo?

 

* Passagem da matriz bidimensional para a função "listar":

No código desenvolvido tenho a passagem para a função da seguinte maneira:

 

listar(nomes,10);

 

pelo que entendi também poderia indicar a posição inicial da matriz com o seguinte código:

 

listar(&nomes[0][0],10);

 

sem a necessidade de alterar o protótipo, então Isis, como você teria feito esta passagem nos dois formatos, movendo a matriz inteira para a função listar e passando a penas o endereço de memória da mesma?

 

 

Novamente, agradeço muito a atenção, após entender bem o conceito, todos os problemas estarão resolvidos.

 

:D

Compartilhar este post


Link para o post
Compartilhar em outros sites

  • Conteúdo Similar

    • Por Mateus GP
      Boa noite.
       
      Estou tendo problemas para compilar um código, não tenho ideia do que está acontecendo.
       
       
      main.cpp
      #include <iostream> #include "vector2.hpp" int main(int, char **) { Vector2f test; //test = (const float)0.0f; test.dot(test); return 0; } vector2.hpp
      #ifndef vector2_header #define vector2_header #include <cmath> template <typename number_t> class Vector2; template <typename number_t> Vector2<number_t> operator+(const Vector2<number_t> &lhs, const Vector2<number_t> &rhs); template <typename number_t> Vector2<number_t> operator+(const Vector2<number_t> &lhs, const number_t rhs); template <typename number_t> Vector2<number_t> operator+(const number_t lhs, const Vector2<number_t> &rhs); template <typename number_t> Vector2<number_t> operator-(const Vector2<number_t> &lhs, const Vector2<number_t> &rhs); template <typename number_t> Vector2<number_t> operator-(const Vector2<number_t> &lhs, const number_t rhs); template <typename number_t> Vector2<number_t> operator-(const number_t lhs, const Vector2<number_t> &rhs); template <typename number_t> Vector2<number_t> operator*(const Vector2<number_t> &lhs, const Vector2<number_t> &rhs); template <typename number_t> Vector2<number_t> operator*(const Vector2<number_t> &lhs, const number_t rhs); template <typename number_t> Vector2<number_t> operator*(const number_t lhs, const Vector2<number_t> &rhs); template <typename number_t> Vector2<number_t> operator/(const Vector2<number_t> &lhs, const Vector2<number_t> &rhs); template <typename number_t> Vector2<number_t> operator/(const Vector2<number_t> &lhs, const number_t rhs); template <typename number_t> Vector2<number_t> operator/(const number_t lhs, const Vector2<number_t> &rhs); template <typename number_t> class Vector2 { public: number_t x; number_t y; Vector2() : x(0.), y(0.) {} Vector2(const number_t x_, const number_t y_) : x(x_), y(y_) {} Vector2(const Vector2 &v2d) : x(v2d.x), y(v2d.y) {} friend Vector2 operator+<number_t>(const Vector2 &lhs, const Vector2 &rhs); friend Vector2 operator+<number_t>(const Vector2 &lhs, const number_t rhs); friend Vector2 operator+<number_t>(const number_t lhs, const Vector2 &rhs); friend Vector2 operator-<number_t>(const Vector2 &lhs, const Vector2 &rhs); friend Vector2 operator-<number_t>(const Vector2 &lhs, const number_t rhs); friend Vector2 operator-<number_t>(const number_t lhs, const Vector2 &rhs); friend Vector2 operator*<number_t>(const Vector2 &lhs, const Vector2 &rhs); friend Vector2 operator*<number_t>(const Vector2 &lhs, const number_t rhs); friend Vector2 operator*<number_t>(const number_t lhs, const Vector2 &rhs); friend Vector2 operator/<number_t>(const Vector2 &lhs, const Vector2 &rhs); friend Vector2 operator/<number_t>(const Vector2 &lhs, const number_t rhs); friend Vector2 operator/<number_t>(const number_t lhs, const Vector2 &rhs); Vector2 &operator=(const Vector2 &rhs); Vector2 &operator=(const number_t &rhs); Vector2 &operator+=(const Vector2 &rhs); Vector2 &operator+=(const number_t rhs); Vector2 &operator-=(const Vector2 &rhs); Vector2 &operator-=(const number_t rhs); Vector2 &operator*=(const Vector2 &rhs); Vector2 &operator*=(const number_t rhs); Vector2 &operator/=(const Vector2 &rhs); Vector2 &operator/=(const number_t rhs); number_t lenghtSq() const; number_t lenght() const; number_t dot(const Vector2 &rhs) const; number_t cross(const Vector2 &rhs) const; Vector2 &rotate(const number_t rad); Vector2 rotated(const number_t rad) const; Vector2 &normalize(); Vector2 normalized() const; number_t distanceSq(const Vector2 &rhs) const; number_t distance(const Vector2 &rhs) const; number_t angle(const Vector2 &rhs) const; Vector2 absv() const; }; typedef Vector2<float> Vector2f; #endif // !vector2_header vector2.cpp
      #include "vector2.hpp" template <typename number_t> Vector2<number_t> operator+(const Vector2<number_t> &lhs, const Vector2<number_t> &rhs) { return Vector2<number_t>(lhs.x + rhs.x, lhs.y + rhs.y); } template <typename number_t> Vector2<number_t> operator+(const Vector2<number_t> &lhs, const number_t rhs) { return Vector2<number_t>(lhs.x + rhs, lhs.y + rhs); } template <typename number_t> Vector2<number_t> operator+(const number_t lhs, const Vector2<number_t> &rhs) { return Vector2<number_t>(lhs + rhs.x, lhs + rhs.y); } template <typename number_t> Vector2<number_t> operator-(const Vector2<number_t> &lhs, const Vector2<number_t> &rhs) { return Vector2<number_t>(lhs.x - rhs.x, lhs.y - rhs.y); } template <typename number_t> Vector2<number_t> operator-(const Vector2<number_t> &lhs, const number_t rhs) { return Vector2<number_t>(lhs.x - rhs, lhs.y - rhs); } template <typename number_t> Vector2<number_t> operator-(const number_t lhs, const Vector2<number_t> &rhs) { return Vector2<number_t>(lhs - rhs.x, lhs - rhs.y); } template <typename number_t> Vector2<number_t> operator*(const Vector2<number_t> &lhs, const Vector2<number_t> &rhs) { return Vector2<number_t>(lhs.x * rhs.x, lhs.y * rhs.y); } template <typename number_t> Vector2<number_t> operator*(const Vector2<number_t> &lhs, const number_t rhs) { return Vector2<number_t>(lhs.x * rhs, lhs.y * rhs); } template <typename number_t> Vector2<number_t> operator*(const number_t lhs, const Vector2<number_t> &rhs) { return Vector2<number_t>(lhs * rhs.x, lhs * rhs.y); } template <typename number_t> Vector2<number_t> operator/(const Vector2<number_t> &lhs, const Vector2<number_t> &rhs) { return Vector2<number_t>(lhs.x / rhs.x, lhs.y / rhs.y); } template <typename number_t> Vector2<number_t> operator/(const Vector2<number_t> &lhs, const number_t rhs) { return Vector2<number_t>(lhs.x / rhs, lhs.y / rhs); } template <typename number_t> Vector2<number_t> operator/(const number_t lhs, const Vector2<number_t> &rhs) { return Vector2<number_t>(lhs / rhs.x, lhs / rhs.y); } template <typename number_t> Vector2<number_t> &Vector2<number_t>::operator=(const Vector2<number_t> &rhs) { if(this != &rhs) { x = rhs.x; y = rhs.y; } return *this; } template <typename number_t> Vector2<number_t> &Vector2<number_t>::operator=(const number_t &rhs) { x = rhs; y = rhs; return *this; } template <typename number_t> Vector2<number_t> &Vector2<number_t>::operator+=(const Vector2<number_t> &rhs) { x += rhs.x; y += rhs.y; return *this; } template <typename number_t> Vector2<number_t> &Vector2<number_t>::operator+=(const number_t rhs) { x += rhs; y += rhs; return *this; } template <typename number_t> Vector2<number_t> &Vector2<number_t>::operator-=(const Vector2<number_t> &rhs) { x -= rhs.x; y -= rhs.y; return *this; } template <typename number_t> Vector2<number_t> &Vector2<number_t>::operator-=(const number_t rhs) { x -= rhs; y -= rhs; return *this; } template <typename number_t> Vector2<number_t> &Vector2<number_t>::operator*=(const Vector2<number_t> &rhs) { x *= rhs.x; y *= rhs.y; return *this; } template <typename number_t> Vector2<number_t> &Vector2<number_t>::operator*=(const number_t rhs) { x *= rhs; y *= rhs; return *this; } template <typename number_t> Vector2<number_t> &Vector2<number_t>::operator/=(const Vector2<number_t> &rhs) { x /= rhs.x; y /= rhs.y; return *this; } template <typename number_t> Vector2<number_t> &Vector2<number_t>::operator/=(const number_t rhs) { x /= rhs; y /= rhs; return *this; } template <typename number_t> number_t Vector2<number_t>::lenghtSq() const { return x * x + y * y; } template <typename number_t> number_t Vector2<number_t>::lenght() const { return sqrt(x * x + y * y); } template <typename number_t> number_t Vector2<number_t>::dot(const Vector2<number_t> &rhs) const { return x * rhs.x + y * rhs.y; } template <typename number_t> number_t Vector2<number_t>::cross(const Vector2<number_t> &rhs) const { return x * rhs.x - y * rhs.y; } template <typename number_t> Vector2<number_t> &Vector2<number_t>::rotate(const number_t rad) { const number_t tx(x), dc(cos(rad)), ds(sin(rad)); x = x * dc - y * ds; y = tx * ds + y * dc; return *this; } template <typename number_t> Vector2<number_t> Vector2<number_t>::rotated(const number_t rad) const { Vector2<number_t> nw(*this); return nw.rotate(rad); } template <typename number_t> Vector2<number_t> &Vector2<number_t>::normalize() { const number_t len(1. / lenght()); x *= len; y *= len; return *this; } template <typename number_t> Vector2<number_t> Vector2<number_t>::normalized() const { Vector2<number_t> nw(*this); return nw.normalize(); } template <typename number_t> number_t Vector2<number_t>::distanceSq(const Vector2<number_t> &rhs) const { const number_t dx(x - rhs.x); const number_t dy(y - rhs.y); return dx * dx + dy * dy; } template <typename number_t> number_t Vector2<number_t>::distance(const Vector2<number_t> &rhs) const { const number_t dx(x - rhs.x); const number_t dy(y - rhs.y); return sqrt(dx * dx + dy * dy); } template <typename number_t> number_t Vector2<number_t>::angle(const Vector2<number_t> &rhs) const { Vector2<number_t> nv(normalized()); number_t ang(nv.dot(rhs.normalized())); if (ang > 1.0) ang = 1.0; if (ang < -1.0) ang = -1.0; return -acos(ang); } template <typename number_t> Vector2<number_t> Vector2<number_t>::absv() const { return Vector2<number_t>(abs(x), abs(y)); } O problema é que aparentemente funciona se copiar o código de vector2.cpp para main.cpp.
       
      Alguém tem alguma sugestão? Se houver outra fora o problema, também é bem-vinda.
       
      Obs: já tentei compilar pelo terminal também.
       
      CMakeLists.txt
       
    • Por quimera
      Bom/boa dia/tarde/noite, estou com um problema (nem notou neh?!):
       
      Estou fazendo uma extensão para preenchimento automático de login e formulário, em alguns sites funciona normalmente, mas existe uns sites que não permitem o preenchimento, e são eles que eu estou buscando auternativas.
       
      eu injeto o texto no input $("input[type=text]").val("Meu texto") mas quando fico observando o valor ou quando envio o formulário simplesmente diz que o input não tem valor (não foi preenchido) mesmo vendo o texto nele.
      O que pode ser?
      Que tipo de mandinga é essa?
      E o que posso fazer pra contornar?
    • Por luciano
      Boa noite pessoal alguém poderia me ajudar por favor,
      gostaria de pagar o valor da função random e colocar na imagem.
      -----função-----
      <p id="demo"></p>
      <script>
      document.getElementById("demo").innerHTML =
      Math.floor((Math.random() * 22) + 1);        
      </script>
      ----------
       <img src="imagens/('#demo').jpg" alt="Card">
       
      Eu ja tentei:
      ('#demo')
      '#demo'
      "#demo"
      Nada funciona.
       
      Por favor me dem uma luz, não manjo de java
      Obrigado
    • Por aegospm
      Olá, amigos.  Eu tenho um array ($array) que foi gerado automaticamente no meu código e seu retorno é este:
      Array ( [0] => Array ( [em] => 0.017142857142857 [vítimas] => 0.017142857142857 [na] => 0.017142857142857 [mulheres] => 0.017142857142857 [criança] => 0.011428571428571 [jovem] => 0.011428571428571 [o] => 0.011428571428571 [nada.] => 0.011428571428571 [morreram] => 0.011428571428571 [hora.] => 0.011428571428571 ) [1] => Array ( [e] => 0.024096385542169 [O] => 0.018072289156627 [anos,] => 0.018072289156627 [do] => 0.018072289156627 [sem] => 0.012048192771084 [atiraram] => 0.012048192771084 [levar] => 0.012048192771084 [Amarante,] => 0.012048192771084 [Natal.] => 0.012048192771084 [com] => 0.012048192771084 ) [2] => Array ( [e] => 0.021276595744681 [de] => 0.021276595744681 [As] => 0.015957446808511 [do] => 0.015957446808511 [um] => 0.015957446808511 [uma] => 0.015957446808511 [Duas] => 0.01063829787234 [identificado] => 0.01063829787234 [cinco] => 0.01063829787234 [18] => 0.01063829787234 ) [3] => Array ( [acordo] => 0.014084507042254 [até] => 0.014084507042254 [De] => 0.014084507042254 [Nascimento,] => 0.014084507042254 [os] => 0.014084507042254 [com] => 0.014084507042254 [na] => 0.014084507042254 [branco,] => 0.0070422535211268 [carro] => 0.0070422535211268 [em] => 0.0070422535211268 ) [4] => Array ( [a] => 0.030769230769231 [de] => 0.025641025641026 [no] => 0.020512820512821 [foi] => 0.015384615384615 [Polícia] => 0.015384615384615 [o] => 0.015384615384615 [26] => 0.01025641025641 [Rodrigues] => 0.01025641025641 [Kelly] => 0.01025641025641 [cabeças] => 0.01025641025641 ) )  
      Eu tenho imprimir cada elemento assim:
      foreach ($array as $key => $value) { echo $key." => ".$value."<br/>"; } Obtenho como resultado o seguinte erro:
      Notice: Array to string conversion in /home/u244186567/public_html/index.php on line 901 Array Notice: Array to string conversion in /home/u244186567/public_html/index.php on line 902 Array Notice: Array to string conversion in /home/u244186567/public_html/index.php on line 901 Array Notice: Array to string conversion in /home/u244186567/public_html/index.php on line 902 Array Notice: Array to string conversion in /home/u244186567/public_html/index.php on line 901 Array Notice: Array to string conversion in /home/u244186567/public_html/index.php on line 902 Array Notice: Array to string conversion in /home/u244186567/public_html/index.php on line 901 Array Notice: Array to string conversion in /home/u244186567/public_html/index.php on line 902 Array Notice: Array to string conversion in /home/u244186567/public_html/index.php on line 901 Array Notice: Array to string conversion in /home/u244186567/public_html/index.php on line 902 Array  Vi aqui como última solução, pois não consegui resolver. Já pesquisei bastante. Como faço para imprimir separadamente cada elemento de $array?
      Quero trabalhar com eles separadamente.
       
       
      Já resolvi... meu $array é um array de arrays. :)
    • Por jeredy
      Tenho um trabalho da faculdade e não consigo fazer rodar o programa corretamente.
      Quando eu coloco o cpf, na hora de imprimir sai um número aleatório. Creio que possa ser por falta de memória pois se coloco um número menor ele sai certo, porém não consigo adicionar memória em cpf.
       
      Obs: ainda não fiz a parte dos menores e da medial do grupo e a parte de imprimir em tabela pois não consegui fazer funcionar nem um básico mas se alguém souber essa parte também e puder me ajudar agradeço!!
       
      #include <stdio.h> #include <stdlib.h> main(){ struct funcionarios{ int *cpf; char nome[30]; int nascimento; float salario; }; int aux=0; //para testar se for 0 antes de armazenar o cpf struct funcionarios *func; int qtdLeitura=0, i=0, cont=0; func = ((struct funcionarios *) (malloc(sizeof(struct funcionarios) * 1))); while(1){ printf("Digite o cpf %d: ", i+1); scanf("%d", &aux); if(aux!= 0){ func.cpf = aux; fflush(stdin); } else{ break; } if(func != NULL){ qtdLeitura++; func = ((struct funcionarios *) realloc(func, sizeof(struct funcionarios) *(qtdLeitura+1))); } printf("Digite o nome %d: ", i+1); scanf("%s", func.nome); printf("Digite o nascimento %d: ",i+1); scanf("%d", &func.nascimento); printf("Digite o salario %d: ",i+1); scanf("%f", &func.salario); cont++; i++; } printf("\n\n"); for(i=0;i<cont;i++){ printf("Cpf %d:%d \n",i+1, func.cpf); printf("Nome %d: %s\n",i+1, func.nome); printf("Nascimento %d: %d\n",i+1, func.nascimento); printf("Salario %d: %.2f\n",i+1, func.salario); } }
       

×

Informação importante

Ao usar o fórum, você concorda com nossos Termos e condições.