/
Inicio :: Foros

 F.A.Q.F.A.Q.                  Conéctese para revisar sus mensajesConéctese para revisar sus mensajes   

Suspicious pointer conversion

 
      Índice del Foro elrincondelc.com -> Principiantes C/C++
Ver tema anterior :: Ver siguiente tema  
AutorMensaje
TylerDurden



Registrado: 31 Ago 2007
Mensajes: 1

MensajePublicado: 07/09/2007 7:23 pm
Título: Suspicious pointer conversion
Se me esta complicando muchisimo el manejo de punteros a TDA


.c:

Código:
#include <stdio.h>
#include <conio.h>
#include "pila.h"
#include "cola.h"
#include "secuen.h"


#define VERDADERO 1
#define FALSO 0


void RevisarFinDatos(int*seguir){

    char rta;
    *seguir = FALSO;

    do {
        printf("\nDesea seguir ingresando datos ? (s/n)\t");
        fflush(stdin);
        scanf ("%c",&rta);
    }while ((rta != 's') && (rta != 'n'));

    if (rta =='s'){
        *seguir = VERDADERO;


    }
    clrscr();
}

void CrearSecuenciaEntrada ( Tsecuencia *se ){

   char c;
   int rsta;

   spreparar(se);

   RevisarFinDatos (&rsta);

   while (rsta == VERDADERO) {
      fflush(stdin);
      printf("Ingrese caracter\n");
      scanf("%c",&c);
      sescribir(se,c);

      RevisarFinDatos (&rsta);

   }

   smarcar(se);
}

void MandarColayPila ( Tcola *c, Tcola *c2 , Tpila *p){

   char ch;

   while (!cvacia(c2) && !cllena(c) && !pllena(p)){
      csacar(c2,&ch);
      cponer(c,ch);
      pponer(p,ch);
   }
}

   
void MandarSecPilayCola ( Tsecuencia *se,Tcola *c, Tpila *p) {

   char ch;

   sleerprim(se,&ch);

   while (!sfin(se) && !cllena(c) && !pllena(p)){
      pponer(p,ch);
      cponer(c,ch);
      sleersig(se,&ch);
   }

   if (!sfin(se)) {
      printf("memoria insuficiente");
      exit(0);
   }
}


void SacarElementosHastaCar ( Tpila *p, char dato){

   char c;

   c = '*' ;

   while (!pvacia(p) && c != dato) {
      psacar(p,&c);
   }
}


void MandarPpalyCpal (Tpila *p, Tcola *p2, Tpila *c, int *cont) {

   char ch;

   while (!pvacia(p) && !pllena(p2) && !cllena(c) ){
      psacar(p,&ch);
      pponer(p2,ch);
      *cont = *cont + 1;
      cponer(c,ch);
   }

   if (!pvacia(p) ) {
      printf ("memoria insuficiente");
      exit(0);
   }
}


void AnalisisPalindromo ( Tpila *p, Tpila *p2, Tcola *c, Tpila *p3, int *es) {

   char c1,c2;

   c1 = '*';
   c2 = '* ';
   *es = 0;

   while (!pvacia(p) && !cvacia(c) && c1 == c2) {
      psacar(p,&c1);
      csacar(c,&c2);
      pponer(p2,c1);
      pponer(p3,c1);
   }

   if ( c1 == c2) {
      *es = 1;
   }
}


void MandarPila ( Tpila *p, Tpila *p2 ) {

   char c;

   while (!pvacia(p2) && !pllena(p)) {

      psacar(p2,&c);
      pponer(p,c);
   }

   if (!pvacia(p2) ) {

      printf ("memoria insuficiente");
      exit(0);
   }
}


void VaciarCola ( Tcola *c ) {

   char ch;

   while (!cvacia(c)) {
      csacar(c,&ch);
   }
}


void MandarCola ( Tcola *c, Tcola *c2) {

   char ch;

   while (!cvacia(c) && !cllena(c2)) {

      csacar(c,&ch);
      cponer(c2,ch);
   }

   if (!cvacia(c)) {
      printf ("memoria insuficiente");
   }       exit(0);
}


void VaciarPila ( Tpila *p){

   char ch;

   while (!pvacia(p)) {
      psacar(p,&ch);
   }

}

void SiguienteCaracter (Tcola *c,Tcola *c2,Tpila *p,Tcola *c3,Tpila *p2,int *aux){

      int ch;

      VaciarPila(p);
      VaciarCola(c3);
      VaciarPila(p2);

      if ( cvacia(c) ) {
         MandarColayPila(c,c2,p);
         csacar(c,&ch);
         *aux = ch;
      }else{
         if ( cvacia(c2) ) {
            MandarColayPila(c2,c,p);
            csacar(c2,&ch);
            *aux = ch;
         }
      }
}


main() {

   int espal,cont,maslargo;
   char car,aux;
   Tpila p,ptop,plar,ppal;
   Tcola c,caux,cpal;
   Tsecuencia sent;

   maslargo = 2;
   cont = 0;

   pcrear(&p);
   pcrear(&ptop);
   pcrear(&plar);
   pcrear(&ppal);

   ccrear(&c);
   ccrear(&caux);
   ccrear(&cpal);

   CrearSecuenciaEntrada (&sent);

   MandarSecPilayCola (&sent,&c,&p);

   csacar(&c,&car);
   aux = car;

   while (( !cvacia(&c) || !cvacia(&caux) ) &&  !pllena(&ppal) && !pllena(&plar) && !cllena(&cpal) && !pllena(&p) && !pllena(&ptop) ) {

      SacarElementosHastaCar(&p,aux);

      pponer(&ppal,aux);
      cponer(&cpal,aux);

      MandarPpalyCpal(&p,&ppal,&cpal,&cont);

      if (cont > 2) {

         AnalisisPalindromo(&ppal,&p,&cpal,&plar,&espal);

         if (espal == 0) {
            MandarPila(&p,&ppal);
            psacar(&p,&car);
            VaciarPila(&plar);
            VaciarCola(&cpal);
         }else{
            if ( cont > maslargo ) {
               maslargo = cont;
               MandarPila(&ptop,&plar);
            }

            SiguienteCaracter(&c,&caux,&p,&cpal,&ppal,&aux);
            cont = 0;
         }
      }else{
         SiguienteCaracter(&c,&caux,&p,&cpal,&ppal,&aux);
         cont = 0;
         }
      }

      if (!cvacia(&c) || !cvacia(&caux) ) {
         printf("Memoria insuficiente\n");
      }else{
         if ( maslargo > 2) {
            while (!pvacia(&ptop)) {
               psacar(&ptop,&car);
               printf("%c",car);
            }
         }else{
            printf("No hay palindromo");
         }
        }
   return (0);
}


Tambien les dejo los TDA q uso

PILA.H (estatica) :

Código:
#define Maxpila 100

#ifndef _TDATO
#define _TDATO
typedef char Tdato;
#endif

struct pila{
   int Cima;
   Tdato Elem[Maxpila];
};

typedef struct pila Tpila;

int pllena (Tpila *p){
   return   p->Cima == Maxpila-1;
}

int pvacia (Tpila *p){
   return p->Cima == -1;
}

void pcrear(Tpila *p){
   p->Cima=-1;
}

void pponer (Tpila *p, Tdato x){
   p->Cima++;
   p->Elem[p->Cima] = x;
}

void psacar(Tpila *p, Tdato *x){
   *x = p->Elem[p->Cima];
   p->Cima--;
}


COLA.H (estatica):

Código:
#define   Maxcola 100

#ifndef _TDATO
#define _TDATO
typedef char Tdato;
#endif


struct cola{
   int Final;
   Tdato Elem[Maxcola];
};

typedef struct cola Tcola;

int cllena (Tcola *p){
   return p->Final == Maxcola-1;
}

int cvacia (Tcola *p){
   return p->Final == -1;
}

void ccrear (Tcola *p){
   p->Final=-1;
}

void cponer (Tcola *p, Tdato x){
   p->Final++;
   p->Elem[p->Final]= x;
}

void csacar(Tcola *p, Tdato *x){
int i;
   *x=p->Elem[0];
   for (i=0; i<p->Final;i++)
      p->Elem[i] = p->Elem[i+1];
   p->Final--;
}


SECUEN.H:

Código:
#include <stdio.h>

#ifndef _TDATO
#define _TDATO
typedef char Tdato;
#endif

typedef FILE* Tsecuencia;

void sleerprim(Tsecuencia *s, Tdato *x){
   *s = fopen("texto.txt","r");
   *x= fgetc(*s);
}

void sleersig(Tsecuencia *s, Tdato *x) {
   *x= fgetc(*s);
}

int sfin(Tsecuencia *s) {
   return (feof(*s));
}

void smarcar(Tsecuencia *s){
   fclose(*s);
}

void sescribir(Tsecuencia *s, Tdato x){
   fputc(x,*s);
}

void spreparar(Tsecuencia *s){
   *s = fopen("texto.txt","w");
}




En total son 15 Warnings "Suspicious pointer Conversion" por el mal uso de punteros...pero es q realmente no me doy cuenta de como utilizarlos con TDA

Si alguien me resuelve este problemilla me gustaria q me diga como lo resolvió, asi aprendo como hacerlo para la proxima

Compilador: Borland C 4.02

Gracias desde ya!
Volver arriba
rir3760



Registrado: 01 Oct 2004
Mensajes: 3657
Ubicación: Mexico
MensajePublicado: 08/09/2007 7:46 am
Título:
Algo que haces en tu programa y que no es bien visto es colocar el codigo fuente de algunas funciones directamente en los headers (archivos de inclusion), uno de los inconvenientes es que no puedes incluirlos en mas de una unidad porque se generarian errores de definicion multiple de funciones y/u objetos.

Lo usual es separar la interface (declaraciones) de la implementacion (definiciones) colocando las primeras en headers (extension "h") y las segundas en unidades (extension "c"), por desgracia no tengo conocimiento de algun buen sitio (o manual) en español que explique en detalle este tema (programacion modular).

Los errores en tu programa son faciles de detectar siempre y cuando utilizes un compilador decente de C (los ya viejos de Borland no lo son) y utilizes este en su modo mas estricto posible.

Por ejemplo utilizando Lcc-win32 los primeros tres errores son:

1) Warning: assignment of pointer to struct cola to pointer to struct pila
Código:
void MandarPpalyCpal(Tpila *p, Tcola *p2, Tpila *c, int *cont)
{
   char ch;
   
   while (!pvacia(p) && !pllena(p2) && !cllena(c) ){
      psacar(p, &ch);
   
   /* ... */

Aqui la funcion "pllena" espera un argumento de tipo "Tpila *" mientras que tu le estas pasando "p2" que es de otro tipo ("Tcola *").

2) Mismo error, tambien dentro de esa misma funcion.
Código:
pponer(p2, ch);

Mismo caso: la funcion "pponer" espera un argumento de tipo "Tpila *" y tu le estas pasando un "Tcola *".

3) Mismo error en la misma funcion, unas lineas mas abajo.
Código:
cponer(c, ch);

El error es al reves: una funcion de colas recibe como argumento un puntero a una pila.

Un saludo
_________________
The capacity to learn is a gift;
The ability to learn is a skill;
The willingness to learn is a choice.
--
Rebec of Ginaz
Volver arriba
      Índice del Foro elrincondelc.com -> Principiantes C/C++
Página 1 de 1Todas las horas están en GMT - 8 Horas

 
No puede crear mensajes
No puede responder temas
No puede editar sus mensajes
No puede borrar sus mensajes
No puede votar en encuestas
Noticias
Enlaces
Cursos
Código fuente
Articulos
FOROS
Tutor online
Curso de C
Curso de C en PDF
¿Necesitas ayuda con tus trabajos?
Contacto
Boletín Novedades
¿Qué es esto?
Qué se cuece por aquí

(c) ElRincondelC.com

Un proyecto de UrlanHeat.com