elhacker.net cabecera Bienvenido(a), Visitante. Por favor Ingresar o Registrarse
¿Perdiste tu email de activación?.

 

 


Tema destacado: Únete al Grupo Steam elhacker.NET


  Mostrar Mensajes
Páginas: [1]
1  Programación / Programación C/C++ / Re: cadena de caracteres en: 27 Abril 2017, 18:41 pm
Cita de: MAFUS en 27 Abril 2017, 12:01 pm
Este último código tiene pérdida de memoria al perder la referencia a cadena. Hay que pensar que es memoria dinámica y hay que liberarla a mano.

Aca lo mejore un poco, ahora le paso un char** para poder modificar la original, primero liberandola y poniendo la cadena nueva. Tambien saque las cadenas temporales y lo hice directamente, las habia usado para ir dandome cuenta que tenia que hacer.

Código
  1.  
  2. #include <stdio.h>
  3. #include <stdlib.h>
  4. #include <string.h>
  5. // Verifica si la cadena find se encuentra dentro cadena. En caso de ser
  6. // verdad devuelve 1, en caso contrario devuelve 0;
  7.  
  8. int string_contiene (char* cadena, char* find) {
  9. 	size_t longCadena = strlen (cadena);
  10. 	size_t longFind = strlen (find);
  11. 	if (longCadena == 0) {
  12. 		return 0;
  13. 	}
  14. 	if ((longFind > 0) && (longFind <= longCadena)) {
  15. 		int count = 0;
  16. 		for (int i=0; ((i<longCadena) && (count<longFind)); i++) {
  17. 			count = 0;
  18. 			if (cadena[i] == find[0]) {
  19. 				for (; ((count<longFind) && (cadena[i] == find[count])); i++, count++);				
  20. 			}
  21. 		}
  22. 		if (count == longFind) {
  23. 			return 1;
  24. 		}
  25. 	}
  26. 	return 0;
  27. }			
  28.  
  29. // Devuelve la posicion donde comienza la cadena find en la cadena.
  30. // Si la cadena find no se encuentra en cadena, devuelve -1.
  31.  
  32. int string_posicion (char* cadena, char* find) {
  33. 	if (string_contiene (cadena, find)) {
  34. 		size_t longCadena = strlen (cadena);
  35. 		size_t longFind = strlen (find);		
  36. 		int aux, count = 0;
  37. 		for (int i=0; ((i<longCadena) && (count<longFind)); i++) {
  38. 			count = 0;
  39. 			aux = i;
  40. 			if (cadena[i] == find[0]) {
  41. 				for (; ((count<longFind) && (cadena[i] == find[count])); i++, count++);				
  42. 			}
  43. 		}
  44. 		if (count == longFind) {
  45. 			return aux;
  46. 		}
  47. 	}
  48. 	return -1;
  49. }			
  50.  
  51. // Recibe una cadena, una cadena a buscar y una cadena a reemplazar.
  52. // Si la cadena find esta en cadena, reemplaza la primera ocurrencia de find en
  53. // cadena por la cadena str y devuelve la nueva cadena, sino, devuelve la misma
  54. // cadena sin modificar. 
  55.  
  56. void string_reemplazar (char** cadena, char* find, char* str) {
  57. 	int posicion = string_posicion (cadena[0], find);
  58. 	if (posicion != -1) {
  59. 		size_t longCadena = strlen (cadena[0]);
  60. 		size_t longFind = strlen (find);
  61. 		size_t longStr = strlen (str);
  62. 		if (longFind <= longStr) {
  63. 			char* cadenaModificada = (char*) malloc (sizeof (char) * longCadena + (longStr - longFind) );
  64. 		}
  65. 		char* cadenaModificada = (char*) malloc (sizeof (char) * longCadena - (longFind - longStr) );			
  66. 		for (int i=0; i<posicion; i++){
  67. 			cadenaModificada[i] = cadena[0][i];
  68. 			cadenaModificada[i+1] = '\0';
  69. 		}		
  70. 		int j = posicion;
  71. 		for (int i=0; i<longStr; j++, i++){
  72. 			cadenaModificada[j] = str[i];
  73. 		}		
  74. 		for (int i=posicion+longFind; i<longCadena; j++, i++){
  75. 			cadenaModificada[j] = cadena[0][i];					
  76. 		}		
  77.                 cadenaModificada[j] = '\0';
  78. 		free (cadena[0]);
  79. 		cadena[0] = cadenaModificada;
  80. 	}	
  81. }
  82.  
  83. int main(){	
  84. 	char* cadena = (char*) malloc (sizeof (char) * 100);
  85. 	char* find = (char*) malloc (sizeof (char) * 50);
  86. 	char* str = (char*) malloc (sizeof (char) * 50);	
  87. 	printf ("Ingrese una cadena:\n");
  88. 	gets (cadena);
  89. 	printf ("Ingrese una palabra a buscar:\n");
  90. 	gets (find);
  91. 	printf ("Ingrese el reemplazo:\n");
  92. 	gets (str);
  93. 	string_reemplazar (&cadena, find, str);
  94. 	printf ("La cadena es:\n%s", cadena);
  95.         free(cadena);
  96.         free(find);
  97.         free(str);
  98. 	return 0;
  99. }	
  100.  
2  Programación / Programación C/C++ / Re: cadena de caracteres en: 27 Abril 2017, 02:11 am
Cita de: brayan en 24 Abril 2017, 04:30 am
mira lo que me piden es esto
por ejemplo el usuario ingresa"hola mundo"
ingresa una palabra a buscar"hola" y una a reemplazar "nada"
al final el programa debe mostrar "nada mundo"
pero que pasa con lo que yo eh realizado solo sirve si la palabra a reemplazar es de menor o igual tamaño a la palabra a buscar ejemplo"hola" para buscar y "nadas" para reemplazar me muestra "nada mundo"
este es el codigo
Código
  1. #include <iostream>
  2. #include <string.h>
  3. using namespace std;
  4.  
  5. int reempla(char *frase,char *palabra,char *elim,char *frase1){
  6. int cont1=0;
  7. int ind = 0;
  8. int letra = 0;
  9. int z=0;
  10. int j=0;
  11.  
  12.  
  13. for(int x=0; x<strlen(frase); x++){
  14.  
  15. if(frase[x] == '\0'){ // si esto se cumple llego al final de la oracion 
  16. break;
  17. }
  18.  
  19. if(frase[x] == palabra[0]){	
  20. [color=red][/color]
  21. ind = 0;
  22.  
  23. letra = 0;
  24. for( j = x; j<x+strlen(palabra); j++){
  25.  
  26. if(frase[j] == palabra[ind]){
  27.  
  28. 	frase1[j]=32;
  29. 	frase1[j]=elim[z];
  30.  
  31.  
  32. z++;
  33.  
  34.  
  35. letra++;
  36. ind++;
  37.  
  38. }
  39.  
  40. }
  41.  
  42. if (letra == strlen(palabra)) {
  43. cont1++;
  44. }
  45.  
  46. }
  47.  
  48. }
  49.  
  50.  
  51. return cont1;
  52. }
  53.  
  54. int main() {
  55.  
  56. int gran=0;
  57. char frase[500];
  58. char frase1[500];
  59. char palabra[50];
  60. char elim[50];
  61.  
  62.  
  63. cout<<"Ingrese la cadena de caracter: "<<endl;
  64. fflush(stdin);
  65. gets(frase);
  66.  
  67.  
  68. for(int z=0;frase[z]!='\0';z++){
  69. 	frase1[z]=frase[z];
  70. }
  71.  
  72.  
  73. cout<<"Ingrese palabra a buscar: "<<endl;
  74. fflush(stdin);
  75. gets(palabra);
  76.  
  77. cout<<"Ingrese palabra a reemplazar: "<<endl;
  78. fflush(stdin);gets(elim);
  79.  
  80. reempla(frase,palabra,elim,frase1);
  81.  
  82. cout<<frase<<endl<<palabra<<endl<<elim<<endl<<frase1<<endl;
  83.  
  84. return 0;
  85. }

· Los códigos deben ir en etiquetas GeSHi

>aquí las reglas del foro
-Engel Lex

Hola que tal, mira, no conozco mucho de c++, yo concozco mas de c, pero te hice aca un programa que funciona como vos queres. Si tenes alguna duda me decis, no creo que sea muy dificil pasarlo a c++. Saludos

Código
  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <string.h>
  4.  
  5. // Verifica si la cadena find se encuentra dentro cadena. En caso de ser
  6. // verdad devuelve 1, en caso contrario devuelve 0;
  7.  
  8. int string_contiene (char* cadena, char* find) {
  9. 	size_t longCadena = strlen (cadena);
  10. 	size_t longFind = strlen (find);
  11. 	if (longCadena == 0) {
  12. 		return 0;
  13. 	}
  14. 	if ((longFind > 0) && (longFind <= longCadena)) {
  15. 		int count = 0;
  16. 		for (int i=0; ((i<longCadena) && (count<longFind)); i++) {
  17. 			count = 0;
  18. 			if (cadena[i] == find[0]) {
  19. 				for (; ((count<longFind) && (cadena[i] == find[count])); i++, count++);				
  20. 			}
  21. 		}
  22. 		if (count == longFind) {
  23. 			return 1;
  24. 		}
  25. 	}
  26. 	return 0;
  27. }			
  28.  
  29. // Devuelve la posicion donde comienza la cadena find en la cadena.
  30. // Si la cadena find no se encuentra en cadena, devuelve -1.
  31.  
  32. int string_posicion (char* cadena, char* find) {
  33. 	if (string_contiene (cadena, find)) {
  34. 		size_t longCadena = strlen (cadena);
  35. 		size_t longFind = strlen (find);		
  36. 		int aux, count = 0;
  37. 		for (int i=0; ((i<longCadena) && (count<longFind)); i++) {
  38. 			count = 0;
  39. 			aux = i;
  40. 			if (cadena[i] == find[0]) {
  41. 				for (; ((count<longFind) && (cadena[i] == find[count])); i++, count++);				
  42. 			}
  43. 		}
  44. 		if (count == longFind) {
  45. 			return aux;
  46. 		}
  47. 	}
  48. 	return -1;
  49. }			
  50.  
  51. // Recibe una cadena, una cadena a buscar y una cadena a reemplazar.
  52. // Si la cadena find esta en cadena, reemplaza la primera ocurrencia de find en
  53. // cadena por la cadena str y devuelve la nueva cadena, sino, devuelve la misma
  54. // cadena sin modificar. 
  55.  
  56. char* string_reemplazar (char* cadena, char* find, char* str) {
  57. 	int posicion = string_posicion (cadena, find);
  58. 	if (posicion != -1) {
  59. 		size_t longCadena = strlen (cadena);
  60. 		size_t longFind = strlen (find);
  61. 		size_t longStr = strlen (str);
  62. 		if (longFind <= longStr) {
  63. 			char* cadenaModificada = (char*) malloc (sizeof (char) * longCadena + (longStr - longFind) );
  64. 		}
  65. 		char* cadenaModificada = (char*) malloc (sizeof (char) * longCadena - (longFind - longStr) );
  66. 		char* temp1 = (char*) malloc (sizeof (char) * longCadena);
  67. 		char* temp2 = (char*) malloc (sizeof (char) * longCadena);
  68. 		temp1[0] = '\0';
  69. 		temp2[0] = '\0';
  70. 		for (int i=0; i<posicion; i++){
  71. 			temp1[i] = cadena[i];
  72. 			temp1[i+1] = '\0';
  73. 		}
  74. 		for (int i=0, j=posicion+longFind; j<longCadena; i++, j++) {
  75. 			temp2[i] = cadena[j];
  76. 			temp2[i+1] = '\0';
  77. 		}
  78. 		size_t longT1 = strlen (temp1), longT2 = strlen (temp2);
  79. 		strcpy (cadenaModificada, temp1);
  80. 		int i=longT1;
  81. 		for (int j=0; j<longStr; j++, i++){
  82. 			cadenaModificada[i] = str[j];
  83. 		}		
  84. 		for (int j=0 ;j<=longT2; j++, i++){
  85. 			cadenaModificada[i] = temp2[j];					
  86. 		}
  87. 		free (temp1);
  88. 		free (temp2);			
  89. 		return cadenaModificada;
  90. 	}
  91. 	return cadena;
  92. }
  93.  
  94. int main(){	
  95. 	char* cadena = (char*) malloc (sizeof (char) * 100);
  96. 	char* find = (char*) malloc (sizeof (char) * 50);
  97. 	char* str = (char*) malloc (sizeof (char) * 50);
  98. 	printf ("Ingrese una cadena:\n");
  99. 	gets (cadena);
  100. 	printf ("Ingrese una palabra a buscar:\n");
  101. 	gets (find);
  102. 	printf ("Ingrese el reemplazo:\n");
  103. 	gets (str);
  104. 	cadena = string_reemplazar (cadena, find, str);
  105. 	printf ("La cadena es:\n%s", cadena);
  106. 	return 0;
  107. }
3  Programación / Programación C/C++ / Re: Listas generales en C en: 24 Abril 2017, 02:59 am
Cita de: CalgaryCorpus en 24 Abril 2017, 01:41 am
Cuando estas insertando, en estos momentos, con el codigo que presentas, indicas explicitamente el tipo de dato que esta siendo guardado., por ejemplo:

Código:
dato_insertar(general, ENTERO, &b);		
dato_insertar(general2, DOUBLE, &num); 	
dato_insertar(general3, CADENA, cadena);
luego te obligas a hacer un switch con ese tipo.

Tengo una solucion que elimina el switch posterior, aunque aun tienes que indicar el tipo de dato que usas al insertar.

Sugiero crear un nuevo campo que guarde un puntero a una funcion que sepa imprimir el dato que estas agregando.

Código:
typedef struct _variante{
	int tipo;
	void* valor;
        void (*f)(void *);
        
} variante;
definir las funciones que saben imprimir, por ejemplo:

Código:
void tipo_entero(void * pTipo) {
  printf("%d", *(int *)pTipo );
}

Las otras funciones son similares, pero usan otros %d en el printf y otro cast.

luego en dato_insertar simplemente se copia el puntero a funcion

Código:
void dato_insertar (dato datos, int tipo, void* d, void (*f)() ){
	datos->tipo = tipo;
	datos->valor = d;
        datos->f = f;
}
y esta funcion se invoca usando el nombre de la funcion a usar para imprimr. Nota que es solo el nombre de la funcion, No como siempre usas las funciones, con parentesis.

Código:
dato_insertar(general, &b, tipo_entero );
   
y finalmente cuando quieras imprimir el dato, solo haces

Código:
dato.f(dato.valor);

y esto imprimira de acuerdo a la funcion que usaste.

Suerte!


Gracias por la respuesta, voy a ver que me sale. Ahora estoy haciendo un menu que me pidieron usando listas generales para crear listas de enteros.
4  Programación / Programación C/C++ / Re: Ayuda cadena de ocurrencias en: 21 Abril 2017, 19:51 pm
Fijate este codigo si te sirve.

Código
  1. int cuenta_ocurrencias (char* str1, char* str2) {
  2. 	if ((str1[0] == '\0') || (str2[0] == '\0')) return 0;	
  3. 	int str1Long = strlen(str1), str2Long = strlen(str2), iter = 0;
  4. 	int i, j;
  5. 	for (i = 0; i < str1Long; i++){				
  6. 		for (j = 0; ((j < str2Long) && (str2[j] == str1[j+i])); j++);
  7. 			if (str2[j] == '\0'){ // Salio del for y si llego al final
  8. 				iter++;             // Es porque la cadena 2 estaba en la cadena 1
  9. 			}		
  10. 	}
  11. 	return iter;
  12. }
  13.  
5  Programación / Programación C/C++ / Re: Juego del ahorcado! C en: 21 Abril 2017, 19:13 pm
Mira, con char palabra te va a tirar error porque es un char, no es una cadena.

Acordate que gets() es una funcion peligrosa, si le pasas una cadena de mayor tamaño que la memoria reservada sigue escribiendo en otras partes de la memoria, lo que podria probocar algun segmentation fault.

Acordate que gets es es :

Char* gets (char* _s). Recibe un puntero a char y devuelve un puntero a char.

Cual es el error que te esta tirando, es de compilacion o cuando ejecutas el programa?.
6  Programación / Programación C/C++ / Re: Listas generales en C en: 21 Abril 2017, 15:00 pm
Cita de: MAFUS en 21 Abril 2017, 11:08 am
He intentado compilar el código y tiene muchos errores. Podría resolverlos pero, la verdad, me ha dado pereza. Si pudieras corregir el código para que no haya mas errores que el lógico que intentas resolver sería de agradecer.

Gracias por responder, aca te dejo todo el codigo en un solo archivo:

Código
  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <stddef.h>
  4.  
  5. typedef struct _GNodo {
  6. 	void *dato;
  7. 	struct _GNodo *sig;
  8. } GNodo;
  9.  
  10. typedef GNodo* GList;
  11.  
  12. typedef void (*FuncionVisitante) (void* dato);
  13.  
  14. GList glist_crear() {
  15. 	return NULL;
  16. }
  17.  
  18. void glist_destruir(GList lista) {
  19. 	GList nodoAEliminar;
  20. 	while (lista != NULL) {
  21. 		nodoAEliminar = lista;
  22. 		lista = lista->sig;
  23. 		free (nodoAEliminar);
  24. 	}	
  25. }		
  26.  
  27. GList glist_agregar_inicio(GList lista, void* dato) {	
  28. 	GList nuevoNodo = malloc (sizeof (GNodo));
  29. 	nuevoNodo->dato = dato;
  30. 	nuevoNodo->sig = lista;
  31. 	return nuevoNodo;
  32. }
  33.  
  34. GList glist_agregar_final (GList lista, void* dato) {	
  35. 	GList nuevoNodo = malloc (sizeof (GNodo));
  36. 	nuevoNodo->dato = dato;
  37. 	nuevoNodo->sig = NULL;
  38. 	if (lista == NULL) {
  39. 		return nuevoNodo;
  40. 	}
  41. 	GList nodo = lista;
  42. 	for (; nodo->sig != NULL; nodo = nodo->sig);
  43. 	nodo->sig = nuevoNodo;
  44. 	return lista;
  45. }	
  46.  
  47. void glist_recorrer (GList lista, FuncionVisitante visit) {
  48. 	for (GList nodo = lista; nodo != NULL; nodo=nodo->sig){
  49. 		visit (nodo->dato);
  50. 	}
  51. }	
  52.  
  53. static void imprimir_entero(void* dato) {
  54.   printf("%d ", (*(int*)dato));
  55. }
  56. // Lo que yo quiero hacer es algo asi, pero no se como hacerlo:
  57. // Si es entero:
  58. //	printf ("%d ", (*(int*)dato));
  59. // Si es double:
  60. //  printf ("%lf ", (*(double*)dato));
  61. // Si es cadena:
  62. //  printf ("%s ", (*(char*)dato));
  63.  
  64. // Como tendria que hacer para saber de alguna forma cual es el tipo
  65. // que esta apuntando el puntero.
  66.  
  67. int main(){
  68. 	int a = 3;
  69. 	char c = 'a';
  70. 	double d = 2.3;		
  71. 	GList lista = glist_crear();
  72. 	lista = glist_agregar_inicio (lista, &a);
  73. 	lista = glist_agregar_inicio (lista, &c);
  74. 	lista = glist_agregar_inicio (lista, &d);
  75. 	lista = glist_agregar_final (lista, &a);
  76. 	printf ("%lf %c %d\n", (*(double*)lista->dato),(*(char*)lista->sig->dato),(*(int*)lista->sig->sig->sig->dato) );	
  77. 	glist_recorrer (lista, imprimir_entero);
  78. 	glist_destruir (lista);
  79. 	return 0;
  80. }
  81.  

yo lo compilo usando gcc listas.c -o lista, asi me funciona bien.

PD: Aca te dejo unas modificaciones que estuve haciendo, haber si voy por buen camino.

Código
  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <stddef.h>
  4.  
  5. #define ENTERO 0
  6. #define DOUBLE 1
  7. #define CADENA 2
  8.  
  9. typedef struct _variante{
  10. 	int tipo;
  11. 	void* valor;
  12. } variante;
  13.  
  14. typedef variante* dato;
  15.  
  16. typedef struct _GNodo {
  17. 	void *dato;
  18. 	struct _GNodo *sig;
  19. } GNodo;
  20.  
  21. typedef GNodo* GList;
  22.  
  23. typedef void (*FuncionVisitante) (dato d);
  24.  
  25. dato dato_crear (){
  26. 	dato nuevoDato = (variante*) malloc (sizeof(variante));
  27. 	return nuevoDato;
  28. }
  29.  
  30. void dato_insertar (dato datos, int tipo, void* d){
  31. 	datos->tipo = tipo;
  32. 	datos->valor = d;
  33. }
  34.  
  35.  
  36. void glist_destruir(GList lista) {
  37. 	GList nodoAEliminar;
  38. 	while (lista != NULL) {
  39. 		nodoAEliminar = lista;
  40. 		lista = lista->sig;
  41. 		free (nodoAEliminar);
  42. 	}	
  43. }		
  44.  
  45. GList glist_crear() {
  46. 	return NULL;
  47. }
  48.  
  49. GList glist_agregar_inicio(GList lista, void* dato) {	
  50. 	GList nuevoNodo = malloc (sizeof (GNodo));
  51. 	nuevoNodo->dato = dato;
  52. 	nuevoNodo->sig = lista;
  53. 	return nuevoNodo;
  54. }
  55.  
  56. GList glist_agregar_final (GList lista, void* dato) {	
  57. 	GList nuevoNodo = malloc (sizeof (GNodo));
  58. 	nuevoNodo->dato = dato;
  59. 	nuevoNodo->sig = NULL;
  60. 	if (lista == NULL) {
  61. 		return nuevoNodo;
  62. 	}
  63. 	GList nodo = lista;
  64. 	for (; nodo->sig != NULL; nodo = nodo->sig);
  65. 	nodo->sig = nuevoNodo;
  66. 	return lista;
  67. }	
  68.  
  69. void glist_recorrer (GList lista, FuncionVisitante visit) {
  70. 	for (GList nodo = lista; nodo != NULL; nodo=nodo->sig){
  71. 		visit (nodo->dato);
  72. 	}
  73. }	
  74.  
  75. static void imprimir_entero(dato d) {  
  76.   switch (d->tipo){
  77. 		case (0):
  78. 			printf ("%d ", *(int*)d->valor);
  79. 			break;
  80. 		case (1):
  81. 			printf ("%lf ", *(double*)d->valor);
  82. 			break;
  83. 		case (2):
  84. 			printf ("%s ", (char*)d->valor);
  85. 			break;
  86. 	}
  87. }
  88. // Lo que yo quiero hacer es algo asi, pero no se como hacerlo:
  89. // Si es entero:
  90. //	printf ("%d ", (*(int*)dato));
  91. // Si es double:
  92. //  printf ("%lf ", (*(double*)dato));
  93. // Si es cadena:
  94. //  printf ("%s ", (*(char*)dato));
  95.  
  96. // Como tendria que hacer para saber de alguna forma cual es el tipo
  97. // que esta apuntando el puntero.
  98.  
  99. int main(){
  100. 	int b = 3;
  101. 	double num = 6.7;
  102. 	char cadena[50] = "mundo ";	
  103. 	dato general = dato_crear();
  104. 	dato general2 = dato_crear();
  105. 	dato general3 = dato_crear();
  106. 	dato_insertar(general, ENTERO, &b);		
  107. 	dato_insertar(general2, DOUBLE, &num); 	
  108. 	dato_insertar(general3, CADENA, cadena); 
  109. 	GList lista = glist_crear();
  110. 	lista = glist_agregar_inicio (lista, general);
  111. 	lista = glist_agregar_inicio (lista, general2);
  112. 	lista = glist_agregar_inicio (lista, general3);
  113. 	//~ lista = glist_agregar_final (lista, &a);		
  114. 	glist_recorrer (lista, imprimir_entero);
  115. 	glist_destruir (lista);
  116. 	return 0;
  117. }
  118.  
7  Programación / Programación C/C++ / Listas generales en C en: 21 Abril 2017, 00:25 am
Hola, estoy tratando de resolver un problema que se me pide con listas. Debo usar listas siguiendo la sig estructura:

Código
  1. typedef struct _GNodo {
  2. 	void *dato;
  3. 	struct _GNodo *sig;
  4. } GNodo;

Tengo 3 archivos, el glist.h, glist.c, y main_g.c. Las funciones que tengo son las basicas, que me permiten crear, destruir, agregar final, agregar inicio, y recorrer.

Código
  1. #include "glist.h"
  2. #include <stdlib.h>
  3.  
  4. GList glist_crear() {
  5. 	return NULL;
  6. }
  7.  
  8. void glist_destruir(GList lista) {
  9. 	GList nodoAEliminar;
  10. 	while (lista != NULL) {
  11. 		nodoAEliminar = lista;
  12. 		lista = lista->sig;
  13. 		free (nodoAEliminar);
  14. 	}	
  15. }		
  16.  
  17. GList glist_agregar_inicio(GList lista, void* dato) {	
  18. 	GList nuevoNodo = malloc (sizeof (GNodo));
  19. 	nuevoNodo->dato = dato;
  20. 	nuevoNodo->sig = lista;
  21. 	return nuevoNodo;
  22. }
  23.  
  24. GList glist_agregar_final (GList lista, void* dato) {	
  25. 	GList nuevoNodo = malloc (sizeof (GNodo));
  26. 	nuevoNodo->dato = dato;
  27. 	nuevoNodo->sig = NULL;
  28. 	if (lista == NULL) {
  29. 		return nuevoNodo;
  30. 	}
  31. 	GList nodo = lista;
  32. 	for (; nodo->sig != NULL; nodo = nodo->sig);
  33. 	nodo->sig = nuevoNodo;
  34. 	return lista;
  35. }	
  36.  
  37. void glist_recorrer (GList lista, FuncionVisitante visit) {
  38. 	for (GList nodo = lista; nodo != NULL; nodo=nodo->sig){
  39. 		visit (nodo->dato);
  40. 	}
  41. }	
  42.  

El problema que estoy teniendo, es que ahora no estoy trabajando con listas donde el dato es un int, estoy trabajando con listas donde el dato es un puntero a void. Yo se que el puntero a void puede apuntar a cualquier tipo de dato, pero para poder desreferenciarlo tengo que aplicar el cast correspondiente al tipo de dato que guarda.

Código
  1. int main(){
  2. 	int a = 3;
  3. 	void *ptr;
  4. 	ptr = &a;
  5. 	printf ("%d", *((int*)ptr)); //convierto ptr a int* y lo desreferencio con *
  6. 	return 0;
  7. }
  8.  

Este es el main que tengo:

Código
  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <string.h>
  4. #include "glist.h"
  5.  
  6.  
  7. static void imprimir_entero(void* dato) {
  8.   printf("%d ", (*(int*)dato));
  9. }
  10.  
  11. int main(){
  12. 	int a = 3;
  13. 	char c = 'a';
  14. 	double d = 2.3;		
  15. 	GList lista = glist_crear();
  16. 	lista = glist_agregar_inicio (lista, &a);
  17. 	lista = glist_agregar_inicio (lista, &c);
  18. 	lista = glist_agregar_inicio (lista, &d);
  19. 	lista = glist_agregar_final (lista, &a);
  20. 	printf ("%lf %c %d\n", (*(double*)lista->dato),(*(char*)lista->sig->dato),(*(int*)lista->sig->sig->sig->dato) );
  21. 	//~ printf ("\n %lf", (*(double*)(lista->dato)));
  22. 	glist_recorrer (lista, imprimir_entero);
  23. 	glist_destruir (lista);
  24. 	return 0;
  25. }
  26.  

Como podria hacer para poder saber cual es el tipo de dato al que apunta void. Como podria hacer lo que esta en la linea 20

Código
  1. printf ("%lf %c %d\n", (*(double*)lista->dato),(*(char*)lista->sig->dato),(*(int*)lista->sig->sig->sig->dato) );

de forma general con la funcion imprimir_entero. El primer caso seria con un entero, un double y un char o cadena. Gracias
Páginas: [1]
WAP2 - Aviso Legal - Powered by SMF 1.1.21 | SMF © 2006-2008, Simple Machines