Mensajes

Existiría la posibilidad si dependiera de mi esa elección, pero es mandato de la universidad.

Aun así por simple curiosidad, y aunque no conocía codeblocks, supongo que buscando con San Google encontraré rápidamente de donde bajarlo.

Aqui tienes el codigo del log de errores:

Código (dos) [Seleccionar] Expandir

Compilador: Default compiler
Building Makefile: "C:\Users\...........\Documents\...............\Makefile.win"
Ejecutando  make clean
rm -f inout.o marnet.o prac.o prac3_private.res prac3.exe
gcc.exe -D__DEBUG__ -c inout.c -o inout.o -I"C:/Dev-Cpp/include"    -ansi -O2 -pg -g3
gcc.exe -D__DEBUG__ -c marnet.c -o marnet.o -I"C:/Dev-Cpp/include"    -ansi -O2 -pg -g3
marnet.c: In function `sup_del_furniture':
marnet.c:399: error: syntax error before '/' token
marnet.c:399: error: missing terminating ' character
marnet.c:404: error: `current' undeclared (first use in this function)
marnet.c:404: error: (Each undeclared identifier is reported only once
marnet.c:404: error: for each function it appears in.)
marnet.c:409: error: syntax error before '/' token
marnet.c:413: error: missing terminating ' character
marnet.c: At top level:
marnet.c:418: error: missing terminating ' character
marnet.c:425: error: missing terminating ' character
marnet.c:430: error: missing terminating ' character
marnet.c: In function `sup_set_profitMargin':
marnet.c:453: error: syntax error before '/' token
marnet.c: At top level:
marnet.c:465: error: syntax error before '/' token
marnet.c:471: error: syntax error before '/' token
marnet.c:473: error: `aux' undeclared here (not in a function)
marnet.c:473: error: initializer element is not constant
marnet.c:473: warning: data definition has no type or storage class
marnet.c:475: error: syntax error before "return"
marnet.c: In function `supOrder_create':
marnet.c:483: error: syntax error before '/' token
marnet.c:489: error: syntax error before '/' token
marnet.c:496: error: syntax error before '/' token
marnet.c: At top level:
marnet.c:510: error: syntax error before "else"
marnet.c:515: error: invalid type argument of `->'
marnet.c:515: warning: data definition has no type or storage class
marnet.c:516: error: syntax error before '->' token
marnet.c:518: error: syntax error before '&' token
marnet.c:518: error: conflicting types for 'get_current_date'
marnet.c:28: error: previous definition of 'get_current_date' was here
marnet.c:518: warning: data definition has no type or storage class
marnet.c:519: error: syntax error before '->' token
marnet.c:524: error: invalid type argument of `->'
marnet.c:524: warning: data definition has no type or storage class
marnet.c:525: error: syntax error before '}' token
marnet.c: In function `get_furniture':
marnet.c:538: error: syntax error before '/' token
marnet.c:548: error: syntax error before '/' token
marnet.c:552: error: syntax error before '/' token
marnet.c: In function `delivery_time':
marnet.c:569: error: syntax error before '/' token
marnet.c:573: error: syntax error before '/' token
marnet.c:577: error: syntax error before '/' token
marnet.c: In function `warehouse_stock':
marnet.c:600: error: syntax error before '/' token
marnet.c: At top level:
marnet.c:610: error: syntax error before '}' token
marnet.c: In function `sort_supOrder':
marnet.c:691: error: syntax error before '/' token
marnet.c:699: error: syntax error before '/' token
marnet.c:705: error: `supOrders' undeclared (first use in this function)
marnet.c:711: error: syntax error before '/' token
marnet.c:715: error: syntax error before '/' token
marnet.c:716: error: syntax error before ')' token
marnet.c: At top level:
marnet.c:727: error: invalid type argument of `->'
marnet.c:727: warning: data definition has no type or storage class
marnet.c:728: error: syntax error before '}' token
marnet.c:729: error: conflicting types for 'aux'
marnet.c:727: error: previous definition of 'aux' was here
marnet.c:729: error: conflicting types for 'aux'
marnet.c:727: error: previous definition of 'aux' was here
marnet.c:729: error: `supOrders' undeclared here (not in a function)
marnet.c:729: error: `i' undeclared here (not in a function)
marnet.c:729: warning: data definition has no type or storage class
marnet.c:730: error: syntax error before '->' token
make.exe: *** [marnet.o] Error 1
Ejecución Terminada


En el archivo de cabecera solo vienen las predeclaraciones de las funciones, y alli no da ningun error. Todos los errores los da en este archivo.

Este es el código que da error en todos los comentarios con doble barra, y en los comentarios con barra y asterisco no da error. ¿Porque ocurre esto?

Código (c) [Seleccionar] Expandir


/*****************************************************************************
         PRAC3
******************************************************************************/

/****************************************************************************
         Includes
******************************************************************************/
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <time.h>
#include "marnet.h"

/******************************************************************************
         Funcions bàsiques
******************************************************************************/

void init_date (tDate *d)
{
     d->minutes =0;
     d->hour = 0;
     d->day = 0;
     d->month = 0;
     d->year = 0;
}

void get_current_date(tDate *d)
{
      time_t now;
      struct tm *tm;
     
      now = time(0);
      tm = localtime(&now);
     
      d->year = tm->tm_year+1900;
      d->month = tm->tm_mon+1;
      d->day = tm->tm_mday;
      d->hour =  tm->tm_hour+1;
      d->minutes = tm->tm_min+1;
}

/*****
         Funcions bàsiques tSupplier
******/
tSupplier newSupplier()
{
      int i;
      tSupplier sup;
     
      sup.idSupplier = 0;
      sup.name[0] = '\0';
      sup.addr[0] = '\0';
      for( i = 0; i < MAX_PHONE; i++ )
           sup.phone[i] = 0;
      sup.firstFur = NULL;
      sup.currFur = NULL;         
      sup.profitMargin = 0.0;
     
      return sup;
}

int sup_get_id( tSupplier s )
{
    return s.idSupplier;
}

void sup_set_id( tSupplier *s, int i )
{
    s->idSupplier = i;
}
void sup_get_name( tSupplier s, tString *st )
{
    strcpy( *st, s.name );
}
void sup_set_name( tSupplier *s, tString n )
{     
    strcpy( s->name, n );
}
void sup_get_addr( tSupplier s, tString *st )
{
     strcpy( *st, s.addr );
}
void sup_set_add( tSupplier *s, tString n )
{     
    strcpy( s->addr, n );
}
void sup_get_phone( tSupplier s, int phone[MAX_PHONE] )
{
     int i;
     for( i = 0; i < MAX_PHONE; i++ )
           phone[i] = s.phone[i];
}
void sup_set_phone( tSupplier *s, int phone[MAX_PHONE] )
{     
      int i;
      for( i = 0; i < MAX_PHONE; i++ )
           s->phone[i] = phone[i];
}

/*****
         Funcions bàsiques tFurniture
*****/
tFurniture newFurniture()
{
    int i;
    tFurniture fur;

    fur.idFurniture = 0;
    fur.idSup = 0;
    fur.nameFur[0] = '\0';
    for( i = 0; i < MAX_SIZES; i++ )
       fur.sizes[i] = 0.0;
    fur.typeFur[0] = '\0';
    fur.color = white;
    fur.costPrice = 0.0;
    fur.retailPrice = 0.0;
    fur.deliveryTime = 0;
    fur.prevFur = NULL;
    fur.nextFur = NULL;
    fur.prevFurType = NULL;
    fur.nextFurType = NULL;

    return fur;
}

int fur_get_id( tFurniture f )
{
    return f.idFurniture;
}
void fur_set_id( tFurniture *f, int i )
{
    f->idFurniture = i;
}
int fur_get_idSupplier( tFurniture f )
{
    return f.idSup;
}
void fur_set_idSupplier( tFurniture *f, int i )
{
    f->idSup = i;
}
void fur_get_name( tFurniture f, tString *st )
{
    strcpy( *st, f.nameFur );
}
void fur_set_name( tFurniture *f, tString n )
{     
    strcpy( f->nameFur, n );
}
void fur_get_sizes( tFurniture f, float r[MAX_SIZES] )
{
     int i;
     for( i = 0; i < MAX_SIZES; i++ )
           r[i] = f.sizes[i];
}
void fur_set_sizes( tFurniture *f, float r[MAX_SIZES] )
{     
      int i;
      for( i = 0; i < MAX_SIZES; i++ )
           f->sizes[i] = r[i];
}
void fur_get_type( tFurniture f, tString *st )
{
    strcpy( *st, f.typeFur );
}
void fur_set_type( tFurniture *f, tString n )
{     
    strcpy( f->typeFur, n );
}
tColor fur_get_color( tFurniture f )
{
    return f.color;
}
void fur_set_color( tFurniture *f, tColor c )
{
    f->color = c;
}
float fur_get_costPrice( tFurniture f )
{
    return f.costPrice;
}
void fur_set_costPrice( tFurniture *f, float r )
{
    f->costPrice = r;
}
float fur_get_retailPrice( tFurniture f )
{
    return f.retailPrice;
}
void fur_set_retailPrice( tFurniture *f, float r )
{
    f->retailPrice = r;
}
int fur_get_deliveryTime( tFurniture f )
{
    return f.deliveryTime;
}
void fur_set_deliveryTime( tFurniture *f, int i )
{
    f->deliveryTime = i;
}

/*****
         Funcions bàsiques tCustomerOrder
*****/
tCustomerOrder newCustOrder()
{
    int i;
    tCustomerOrder co;
   
    co.idOrder = 0;
    co.nameCust[0] = '\0';
    co.addrCust[0] = '\0';
    for( i = 0; i < MAX_PHONE; i++ )
        co.phoneCust[i] = 0;
    init_date(&co.createdDate);
    co.state = cPending;
    co.firstItem = NULL;
    co.currItem = NULL;
    co. nextCustOrder = NULL;
           
    return co;
}

int custOrd_get_id( tCustomerOrder co )
{
    return co.idOrder;
}
void custOrd_set_id( tCustomerOrder *co, int i )
{
    co->idOrder = i;
}
void custOrd_get_name( tCustomerOrder co, tString *st )
{
    strcpy( *st, co.nameCust );
}
void custOrd_set_name( tCustomerOrder *co, tString n )
{     
    strcpy( co->nameCust, n );
}
void custOrd_get_addr( tCustomerOrder co, tString *st )
{
    strcpy( *st, co.addrCust );
}
void custOrd_set_addr( tCustomerOrder *co, tString n )
{     
    strcpy( co->addrCust, n );
}
void custOrd_get_phone( tCustomerOrder co, int phone[MAX_PHONE] )
{
     int i;
     for( i = 0; i < MAX_PHONE; i++ )
           phone[i] = co.phoneCust[i];
}
void custOrd_set_phone( tCustomerOrder *co, int phone[MAX_PHONE] )
{     
      int i;
      for( i = 0; i < MAX_PHONE; i++ )
           co->phoneCust[i] = phone[i];
}
tDate custOrd_get_createdDate( tCustomerOrder co )
{
    return co.createdDate;
}
void custOrd_set_createdDate( tCustomerOrder *co, tDate td )
{     
    co->createdDate = td;
}
tCustState custOrd_get_state( tCustomerOrder co )
{
    return co.state;
}
void custOrd_set_state( tCustomerOrder *co, tCustState st )
{     
    co->state = st;
}


/*****
         Funcions bàsiques tOrderRow
*****/
int orderRow_get_idProv( tOrderRow o )
{
    return o.idProv;
}
void orderRow_set_idProv( tOrderRow *o, int i )
{
    o->idProv = i;
}
int orderRow_get_idFur( tOrderRow o )
{
    return o.idFur;
}
void orderRow_set_idFur( tOrderRow *o, int i )
{
    o->idFur = i;
}
int orderRow_get_unit( tOrderRow o )
{
    return o.unit;
}
void orderRow_set_unit( tOrderRow *o, int i )
{
    o->unit = i;
}
float orderRow_get_unitCostPrice( tOrderRow o )
{
    return o.unitCostPrice;
}
void orderRow_set_unitCostPrice( tOrderRow *o, float i )
{
    o->unitCostPrice = i;
}
float orderRow_get_profitMargin( tOrderRow o )
{
    return o.profitMargin;
}
void orderRow_set_profitMargin( tOrderRow *o, float i )
{
    o->profitMargin = i;
}

/*****
         Funcions bàsiques tSupplierOrder
*****/
tSupplierOrder *newSupplierOrder()
{
      int i;
      tSupplierOrder *supOrd;
     
      supOrd = malloc(sizeof(tSupplierOrder));
     
      supOrd->idOrder = 0;
      supOrd->idSupplier = 0;
      init_date(&supOrd->createdDate);
      init_date(&supOrd->receivedDate);
      supOrd->state = sPending;
      supOrd->firstItem = NULL;
      supOrd->currItem = NULL;
      supOrd->totalPrice = 0;
      supOrd->nextSupOrder = NULL;
     
      return supOrd;
}
int supOrd_get_id( tSupplierOrder so )
{
    return so.idOrder;
}
void supOrd_set_id( tSupplierOrder *so, int i )
{
    so->idOrder = i;
}
int supOrd_get_idSupplier( tSupplierOrder so )
{
    return so.idSupplier;
}
void supOrd_set_idSupplier( tSupplierOrder *so, int i )
{
    so->idSupplier = i;
}
tDate supOrd_get_createdDate( tSupplierOrder so )
{
    return so.createdDate;
}
void supOrd_set_createdDate( tSupplierOrder *so, tDate td )
{     
    so->createdDate = td;
}
tDate supOrd_get_receivedDate( tSupplierOrder so )
{
    return so.receivedDate;
}
void supOrd_set_receivedDate( tSupplierOrder *so, tDate td )
{     
    so->receivedDate = td;
}
tSupState supOrd_get_state( tSupplierOrder so )
{
    return so.state;
}
void supOrd_set_state( tSupplierOrder *so, tSupState st )
{
    so->state = st;
}
float supOrd_get_totalPrice( tSupplierOrder so )
{
    return so.totalPrice;
}
void supOrd_set_totalPrice( tSupplierOrder *so, float r )
{
    so->totalPrice = r;
}

/*****
         Funcions basiques: Esborrar moble del cataleg d'un proveidor
*****/
void sup_del_furniture (tSupplier *s, tFurniture f)
{
     // recuperem la llista de tFurniture's del supplier
     tFurniture *current;
     
     // Busquem el moble a esborrar
     current = s->firstFur;
     while( (current != NULL) && (current->idFurniture != f.idFurniture))
     {
            current = current->nextFur;
     }
     
     // Si hem trobat el moble: actualitzem apuntadors de les llistes doblement encadenades a les queal pentany
     if( current->idFurniture == f.idFurniture )
     {
         // Llista de mobles de tSupplier
         // Actualitzem apuntador seguent de prevFur a l'element seguent al que estem esborrant
         if( current->prevFur )
         {
             current->prevFur->nextFur = current->nextFur;
         }
         // Actualitzem apuntador anterior de nextFur a l'element anterio al que estem esborrant
         if( current->nextFur )
         {
             current->nextFur->prevFur = current->prevFur;
         }
         
         // Llista de mobles de tType
         // Actualitzem apuntador seguent de prevFurType a l'element seguent al que estem esborrant
         if( current->prevFurType )
         {
             current->prevFurType->nextFurType = current->nextFurType;
         }
         // Actualitzem apuntador anterior de nextFurType a l'element anterio al que estem esborrant
         if( current->nextFurType )
         {
             current->nextFurType->prevFurType = current->prevFurType;
         }
     }
}


/*****
         Funcions basiques: Crear/Consultar/Modificar el percentatge de beneficis a un preu de cost
*****/
float sup_get_profitMargin (tSupplier s)
{
      return s.profitMargin;
}
     
void sup_set_profitMargin (tSupplier *s, float r)
{
     tFurniture *furAux;
     
     s->profitMargin = r;
     
     // Hem de recorrer tot el cataleg de mobles per actualitzar el PVP amb el nou percentatge de beneficis
     furAux = s->firstFur;
     while(furAux != NULL)
     {
        furAux->retailPrice = furAux->costPrice + (furAux->costPrice * r / 100);
        furAux = furAux->nextFur;
     }
}
/*****
         Funcions basiques: Crear comanda a proveïdors a partir de la comanda del client
*****/

// Afegim funcio auxiliar getNewSupIdOrder que ens retorna un nou id de comanda proveidors
int getNewSupIdOrder(int idCustOrder, int idSupplier)
{
    tString aux;
    int newID;

    // Per crear un nou idSupplier per a la comanda a proveidors concatenem id comanda client amb id proveidor
    sprintf(aux, "%d%d", idCustOrder, idSupplier);
    newID = atoi(aux);
       
    return newID;
}

tSupplierOrder *supOrder_create(tCustomerOrder co)
{
     tOrderRow *rowCus;
     tSupplierOrder *supOrd, *firstSupOrd, *currentSupOrd, *auxSupOrd;
     
     // Inicialitzem la llista
     supOrd = malloc(sizeof(tSupplierOrder));
     // so = NULL;
     firstSupOrd = supOrd;
     currentSupOrd = supOrd;

     // Creem un tSupplierOrder per a cadascun dels diferents proveidors que tenim en la comanda de client

     // Buscar primer tOrderRow (firstItem) i recorrer tota llista
     rowCus = co.firstItem;
     while(rowCus != NULL)
     {
          auxSupOrd = firstSupOrd;
          // Comprovem si ja tenim inicialitzada una comanda a proveidor
          while((auxSupOrd != NULL) && (rowCus->idProv != auxSupOrd->idSupplier))
          {
                    auxSupOrd = auxSupOrd->nextSupOrder;               
          }
          // Comprovem si hem trobat comanda a proveidor ja inicialitzada
          if(rowCus->idProv == auxSupOrd->idSupplier)
          {
                        //Afegim un nou tOrderRow a la comanda a proveidor
                        rowCus->nextOrderRowSup = NULL;
                        auxSupOrd->currItem->nextOrderRowSup = rowCus;
                        auxSupOrd->currItem = auxSupOrd->currItem->nextOrderRowSup;
                        auxSupOrd->totalPrice += rowCus->unit * rowCus->unitCostPrice;
          }
          else
          {
              // No hem trobat el proveidor a la llista, hem de crear una nova comanda
              currentSupOrd->nextSupOrder = malloc(sizeof(tSupplierOrder));
              currentSupOrd->nextSupOrder = newSupplierOrder();
              currentSupOrd = currentSupOrd->nextSupOrder;
              currentSupOrd->idOrder = getNewSupIdOrder(co.idOrder, currentSupOrd->idSupplier);
              currentSupOrd->idSupplier = rowCus->idProv;
              get_current_date(&currentSupOrd->createdDate);
              rowCus->nextOrderRowSup = NULL;
              currentSupOrd->firstItem = rowCus;
              currentSupOrd->currItem = rowCus;
              currentSupOrd->totalPrice = rowCus->unit * rowCus->unitCostPrice;
          }
          rowCus = rowCus->nextOrderRow;
     }
}


/*****************************************************************************
         Operacions especials delivery_time i warehouse_stock.
******************************************************************************/
tFurniture *get_furniture( tShop ts, int idSup, int idFur)
{
           tSupplier sup;
           tFurniture *fur;
           int i;
                   
           fur = NULL; //Important per si no trobem proveidor o moble
           i = 0;
           
           // Busquem el proveidor
           while ((i<MAX_SUPPLIERS) && (ts.suppliers[i].idSupplier != idSup))
                 i++;
           
           if(ts.suppliers[i].idSupplier == idSup)
           {
                sup = ts.suppliers[i];
                // Busquem el moble
                fur = sup.firstFur;
                while((fur != NULL) && (fur->idFurniture !=idFur))
                           fur = fur->nextFur;
                // Quan sortim del bucle while o hem trobat el moble o estem al final de la llista
           }

           return fur;
}

/*****
        delivery_time: Calcula el termini d'entrega d'una comanda client.
        Depèn del màxim termini entrega (per part dels proveïdors) de tota la comanda
******/
int delivery_time(tShop ts, tCustomerOrder co)
{
    int maxDays;
    tOrderRow *row;
    tFurniture *fur;
   
    maxDays = 0;
    // Per a cada moble en la comanda de client busquem el corresponent tFurniture
    row = co.firstItem;
    while (row != NULL)
    {
          // Busquem moble
          fur = get_furniture(ts, row->idProv, row->idFur);
          if(fur!=NULL)
          {
               // Si el termini entrega es major que el maxim, actualitzem el maxim
               if(maxDays < fur->deliveryTime)
                    maxDays = fur->deliveryTime;
          }
          // Busquem seguent moble
          row = row->nextOrderRow;
    }
         
    return maxDays;
}

/*****
        warehouse_stock: Estoc del magatzem, és a dir, llistat de comandes rebudes i pendents d'entregar al client.
        Entenem que llistats surten per pantalla
*****/
void warehouse_stock(tShop ts)
{
     tCustomerOrder *custOrder;

     printf("WAREHOUSE STOCK:\n\n");     
     custOrder = ts.firstCustOrder;
     while(custOrder != NULL)
     {
          // Imprimim per pantalla la comanda
          if(custOrder->state == inWarehouse)
          {
               printf("ID:%d\tCUSTOMER:%s\tDATE:%d/%d/%d\tSTATE:%s\n",
                    custOrder->idOrder, custOrder->nameCust,
                    custOrder->createdDate.day, custOrder->createdDate.month,
                    custOrder->createdDate.year, custOrder->state);
          }
          custOrder = custOrder->nextCustOrder;
     }
}


/*****************************************************************************
         funció sort_supOrder que ordena la llista de comandes a proveïdors
         de manera descendent, segons el preu total de la comanda.
         Per a la ordenació utilitza el mètode de classificació Merge Sort.
******************************************************************************/
     
/*****
      combine: funcio auxiliar que combina dues llistes de manera ordenada
*****/
void combine (tSupplierOrder out[], int left, int middle, int right, int size)
{
  int r, i, j;
  tSupplierOrder outAux[size];
 
  r = left;
  i = left;
  j = middle + 1;

  while ((i <= middle) && (j <= right) && (j < size))
  {
     if(out[i].totalPrice > out[j].totalPrice)
     {
        outAux[r] = out[i];
        i++;
        r++;
     }
     else
     {
          outAux[r] = out[j];
          j++;
          r++;
     }
  }
 
  while(i <= middle)
  {
          outAux[r] = out[i];
          i++;
          r++;
  }
 
  while(j <= right)
  {
          outAux[r] = out[j];
          j++;
          r++;
  }
 

  for(i=left; i<=right; i++)
          out[i] = outAux[i];
}

/*****
      merge_sort: funcio auxiliar recursiva que aplica el metode Merge Sort
*****/
void merge_sort (tSupplierOrder s[], int left, int right, int size)
{
   int middle;
   tSupplierOrder *listLeft, *listRight;

   if (left < right)
   {
      middle = (left + right) / 2;
      merge_sort(s, left, middle, size);
      merge_sort(s, middle+1, right, size);
      combine(s, left, middle, right, size);
   }
}

void sort_supOrder(tShop *t)
{
     int left, right, i, rightAux;
     tSupplierOrder *aux, *aux2;
     
     left = 0;
     right = 0;
     
     // Calculem el numero de comandes de proveidors que tenim i ho desem right (limit dret)
     aux = t->firstSupOrder;
     while(aux != NULL)
     {
               right++;
               aux = aux->nextSupOrder;
     }

     // Creem una copia de la llista en el vector i anem esborrant i alliberant memoria
     tSupplierOrder supOrders[right];

     aux = t->firstSupOrder;
     for(i=0; i<right; i++)
     {
              supOrders[i] = *aux;
              aux2 = aux;
              aux = aux->nextSupOrder;
              free(aux2);
     }

     // Cridem a la funcio merge_sort amb el nou vector i els limits Esquerre i Dret
     rightAux = right;
     merge_sort(supOrders, left, right-1, right);

     // Mostrem resultats per pantalla
     for(i=0; i<right; i++)
     {
              printf("idOrder:%d\ttotalPrice:%f\n", supOrders[i].idOrder, supOrders[i].totalPrice);
     }
     // Restaurem llista i actualitzem apuntadors
     aux = malloc(sizeof(tSupplierOrder));
     t->firstSupOrder = aux;
     for(i=0; i<right-1; i++)
     {
              *aux = supOrders[i];
              aux->nextSupOrder = malloc(sizeof(tSupplierOrder));
              aux = aux->nextSupOrder;
     }
     *aux = supOrders[i];
     aux->nextSupOrder = NULL;
}




Hola a todos.

Esta es una cuestión simple para expertos como vosotros.

¿por que me da error el compilador al compilar un programa en todos los comentarios con la doble barra? Es como si no reconociese ese tipo de comentarios.

Y no encuentro el lugar donde indicarle al DEV-C++ para que los reconozca.

Saludos.
Jose.

Tengo un problema con un puntero que me esta volviendo loco, hace lo que le da la gana, reserve o no memoria para el. Aqui dejo la estructura:

Código (c) [Seleccionar] Expandir


/*****************************************************************************
        PRAC3
******************************************************************************/

#ifndef MARNET_H
#define MARNET_H

/*****************************************************************************
        Constants
******************************************************************************/
#define MAX_SUPPLIERS   20
#define MAX_CATEGORIES  5
#define MAX_NAME        300
#define MAX_PHONE       9
#define MAX_SIZES       3


/*****************************************************************************
        TADs
******************************************************************************/
typedef enum{white, pine, cherryTree, black} tColor;
typedef enum{hall, dinningRoom, bedroom, ofice, kitchen, washroom} tCategoryName;
typedef enum{cPending, inWarehouse, deliveredToClient} tCustState;
typedef enum{sPending, received } tSupState;

typedef char tString[MAX_NAME+1];

typedef enum { FALSE, TRUE } bool;

typedef struct
{
       int day, month, year;
       int hour, minutes;
}tDate;

typedef struct tFurniture
{
       int idFurniture;
       int idSup;
       tString nameFur;
       float sizes[MAX_SIZES];
       tString typeFur;
       tColor color;
       float costPrice;
       float retailPrice;
       int deliveryTime;
       struct tFurniture *prevFur, *nextFur;
       struct tFurniture *prevFurType, *nextFurType;
}tFurniture;

typedef struct tType
{
       tString typeName;
       tFurniture *firstFur, *currFur;
       struct tType *prevType, *nextType;
} tType;

typedef struct
{
     tCategoryName catName;
     tType *primType, *currType;
} tCategory;

typedef struct
{
       int idSupplier;
       tString name;
       tString addr;
       int phone[MAX_PHONE];
       tFurniture *firstFur, *currFur;
       float profitMargin;
}tSupplier;

typedef struct tOrderRow
{
       int idProv;
       int idFur;
       int unit;
       float unitCostPrice;
       float profitMargin;
       struct tOrderRow *nextOrderRow, *nextOrderRowSup;
}tOrderRow;

typedef struct tCustomerOrder
{
       int idOrder;
       tString nameCust;
       tString addrCust;
       int phoneCust[MAX_PHONE];
       tDate createdDate;
       tCustState state;
       tOrderRow *firstItem, *currItem;
       struct tCustomerOrder *nextCustOrder;
}tCustomerOrder;

typedef struct tSupplierOrder
{
       int idOrder;
       int idSupplier;
       tDate createdDate;
       tDate receivedDate;
       tSupState state;
       tOrderRow *firstItem, *currItem;
       float totalPrice;
       struct tSupplierOrder *nextSupOrder;                  
}tSupplierOrder;

typedef struct
{
       tSupplier suppliers[MAX_SUPPLIERS];
       int currSupplier, numSupplier;
       tCategory categories[MAX_CATEGORIES];
       tCustomerOrder *firstCustOrder, *currCustOrder;
       tSupplierOrder *firstSupOrder, *currSupOrder;
}tShop;


Estas son las llamadas que me estan volviendo loco:

Código (c) [Seleccionar] Expandir


void cat_add_furniture (tCategory *c, tFurniture *f )
{
    tType *typeAux, *typeAux2;
    tFurniture *furAux;
   
    typeAux = (tType*) malloc (sizeof(tType));
    if (typeAux == NULL)
    {
                printf("ERROR cat_add_furniture: not enough memory\n");
                f = NULL;
                return;
    }
   
    furAux = (tFurniture*) malloc (sizeof(tFurniture));
    if (furAux == NULL)
    {
                printf("ERROR cat_add_furniture: not enough memory\n");
                f = NULL;
                return;
    }


  /* Buscamos en la lista tType bajo tCategory*/
    typeAux = c->primType;
   
    while( (typeAux->nextType != NULL) && (typeAux->typeName != f->typeFur))
    {
           typeAux = typeAux->nextType;
    }
    /* Comprobamos si ya tenemos el tType en la lista, sino hemos de añadir un nuevo tType*/
    if( typeAux->typeName == f->typeFur)
    {
        /* Ya tenemos el tipo en la lista, buscamos la posición donde insertar el nuevo mueble.
        También comprobamos que el mueble no haya sido ya insertado.*/
        furAux = typeAux->firstFur;
        while(((furAux->nextFurType != NULL) && (f->idFurniture!=furAux->idFurniture)) || (f->retailPrice > furAux->retailPrice))
        {                    
               furAux = furAux->nextFurType;
        }
        if ( (furAux->idFurniture != f->idFurniture) || (f->retailPrice > furAux->retailPrice) )
        {
           /* Tenemos a furAux apuntando a la ultima posición de la lista o al mueble siguiente
            ordenado por PVP. Añadimos el nuevo mueble, si no existe ya en la lista */
           f->nextFurType = furAux->nextFurType;
           f->prevFurType = furAux->prevFurType;
           furAux->nextFurType = f;
        }
    }
    else
    {
        /* No hemos encontrado el tipo y typeAux esta posicionado al final de la lista. Añadimos el nuevo tipo */
        typeAux2 = (tType*) malloc (sizeof(tType));
        if(typeAux2==NULL)
        {
            printf("ERROR cat_add_furniture: not enough memory\n");
            f = NULL;
            return;
        }
        typeAux->nextType = typeAux2;
        strcpy(typeAux->typeName, f->typeFur);
        typeAux2->prevType = typeAux;
        typeAux2->nextType = NULL;
        typeAux2->firstFur = f;
        typeAux2->currFur = f;
        f->nextFurType = NULL;
        f->prevFurType = NULL;
    }
    free (typeAux);
    free (typeAux2);
    free (furAux);
}

int sup_add_furniture(tShop *t)
{
   int i,idSup,idFur,delivery_time,numCat;
   float margin,cost,retail_price,s[MAX_SIZES];
   bool found;
   tString name,type;
   tColor color;
   
   margin = 0.0;
   
   /* Leemos los datos del mueble a añadir */
   printf ("\nSupplier : ");
   idSup = read_integer ();
   idSup = idSup - 1;
   
   printf("\nFurniture id : ");
   idFur = read_integer ();
   
   printf("\nFurniture Name : ");
   read_string (name);
   
   printf("\nFurniture Type : ");
   read_string (type);
   
   printf("\nFurniture width : ");
   s[0]= read_real ();
   
   printf("\nFurniture Height : ");
   s[1] = read_real ();
   
   printf("\nFurniture Depth : ");
   s[2] = read_real ();
   
   printf("\nFurniture Colour : ");
   color = read_colour ();
   
   printf("\nFurniture cost price : ");
   cost = read_real();
   
   printf("\nFurniture Delivery time : ");
   delivery_time = read_integer ();
   
   printf("\nHow many categories? ");
   numCat = read_integer ();
   
   if (numCat>MAX_CATEGORIES)
      numCat = MAX_CATEGORIES;
   
   tCategory cat[numCat];
   
   for (i=0;i<numCat;i++)
   {
       cat[i].catName = hall;
       cat[i].primType = NULL;
       cat[i].currType = NULL;
   }
   
   for (i=0;i<numCat;i++)
   {
       printf("\nEnter a new Category (H:Hall D:diningroom  O:office K:Kitchen B:Bedroom W:Washroom): ");
       cat[i].catName = read_category();
       if (cat[i].catName == -1)
       {
             error ("sup_add_furniture: undefined category");
             return cat[i].catName;              
       }
   }
 
   /* Buscar proveedor al cual tenemos que añadir el mueble. Si no existe acaba el programa con un mensaje de error */
   if (search_supplier (*t,idSup) == -1)
   {
        error (ERROR_SUPPL_NOT_FOUND);
        idSup = -1;
        return idSup;
   }
     
   /* Crear el objeto */
   tFurniture *newFur = (tFurniture*) malloc (sizeof(tFurniture));
   if(newFur==NULL)
        {
            printf("ERROR sup_add_furniture: not enough memory\n");
            idSup= -1;
            return idSup;
        }
   *newFur = newFurniture ();
   
   /* Actualizamos campos del objeto */
   fur_set_idSupplier( newFur, idSup );
   fur_set_id( newFur, idFur );
   fur_set_name( newFur, name );
   fur_set_color( newFur, color );
   fur_set_costPrice( newFur, cost );
   fur_set_deliveryTime(newFur, delivery_time );
   fur_set_sizes( newFur, s );
   fur_set_type( newFur, type );
   
   /* Calcular PVP del mueble : precio de coste + margen de beneficio del proveedor */
   
   if (idSup > -1) margin = sup_get_profitMargin (t->suppliers[idSup]);
   margin = 1 + (margin / 100);
   retail_price = cost * margin;
   fur_set_retailPrice( newFur, retail_price );  
   
   /* Añadir el mueble, dentro de la estructura tShop, a las categorias y tipos correspondientes */
   
   for (i=0;i<numCat;i++)
       cat_add_furniture (&cat[i], newFur );
   if (newFur != NULL)
      idSup = newFur->idSup;
   else
        idSup = -1;
       
   free (newFur);
   return idSup;
}


En concreto en la funcion cat_add_furniture, a partir de las lineas donde esta el comentario, /* Buscamos en la lista tType bajo tCategory*/, parece como que no asigna el valor de c->primType a typeAux. Y he probado reservandole memoria y sin reservasela. El resultado siempre es el mismo, entra en el bucle del siguiente while aunque sea el primer registro que graba, y no debería ser así.

Alguien puede aportarme algo de luz al caso.

Gracias.

Saludos.
Chema.

Hola  Akai.

Gracias por tus consejos y ayudas.

Al final lo resolvi, creandome un tFurniture auxiliar y asignandole el valor del tFurniture original que deseaba enviar a la funcion y no me dejaba, asi se lo pase correctamente. Quedo así la cosa:

Código (c) [Seleccionar] Expandir

void sup_set_profitMargin (tSupplier *s, float r)
{
     tString name;
     float price;
     tFurniture *pf,f;
     
     s->profitMargin = r;
 
     sup_firstFur (s, pf);
     
     if (pf!=NULL)
        {
             sup_get_name(*s,name);
             printf("-----------------------------------------------------------------");
             printf("Supplier: %s \n",name);
             
             if (s->idSupplier == s->currFur->idSup)
                       s->currFur->retailPrice = s->profitMargin * s->currFur->costPrice;
             while (s->currFur!=NULL)
                   {
                        f=*s->currFur;     
                        fur_get_name(f,name);
                        printf("Furniture: %s \t",name);
                       
                        price=fur_get_retailPrice(f);
                        printf("Old retail price: %d \t", price);
                       
                        s->currFur->retailPrice = s->profitMargin * s->currFur->costPrice;
                       
                        f=*s->currFur;
                        price=fur_get_retailPrice(f);
                        printf("New retail price: %d \n", price);
                       
                        sup_next_Fur (s,pf);
                   }
             printf("-----------------------------------------------------------------");
        }
}


Gracias a todos los que han respondido o me han intentado ayudar, al final salio bien la cosa.

Muchas gracias.

Saludos.
Chema.

Ya sabia eso acemax, de todas formas gracias por tu aportacion, el caso es como transformo ese parametro en un tFurniture en vez de un puntero, que es lo que ahora mismo tengo, ya que el encabezado de la funcion no lo puedo modificar, y estoy un pelin verde en el tema de pasos por valor o por referencia.

Entiendo cuando debo pasarlos por valor o por referencia pero en C se me resiste como indicarselo para que lo compile correctamente y no de errores. Entonces siempre voy tanteando si le pongo el asterisco, el punto o el ->.

Alguna ayudita con el dichoso puntero?????

Gracias.

Saludos.
Chema.

Si, perdon, se me olvido colocar el  nombre de la estructura, y parece que al hacerlo ya no me da el fallo de dereferencing, a veces es una tonteria pero cuando te ciegas, es que no hay manera de resolverlo.

Sigo sufriendo el otro fallo de incompatible tipo de argumento, que me sigue dando en la linea que marque con el comentario correspondiente...Alguna sugerencia??????

Gracias por la ayuda Akai.

Saludos.
Chema.

Hola a todos.

Estoy muy agobiado con una practica de programacion que debo entregar pronto y no se como resolver un problema leve que me ha surgido que me tiene muy atrancado, a ver si me podeis echar un cable y ayudarme. Esta es la funcion y la definicion de la estructura:

Código (c) [Seleccionar] Expandir



typedef struct tSupplier{
int idSupplier;
    tString name;
    tString addr;
    int phone[MAX_PHONE];
    struct tFurniture *firstFur,*currFur;                               
    float profitMargin;
} tSupplier;

typedef struct {
int idFurniture;
int idSup;
tString nameFur;
float sizes[MAX_SIZES];
tString typeFur;
tColor color;
float costPrice;
float retailPrice;
int deliveryTime;
struct tFurniture *prevFur, *nextFur;                               
struct tFurniture *prevFurType, *nextFurType;
} tFurniture;

........

void fur_get_name (tFurniture f, tString n)
{
     strcpy (n,f.nameFur);       
}

.......

void sup_set_profitMargin (tSupplier *s, float r)
{
     tString name;
     float price;
     
     s->profitMargin = r;
   
     s->currFur=s->firstFur;
     if (s->currFur!=NULL)
        {
             sup_get_name(*s,name);
             printf("-----------------------------------------------------------------");
             printf("Supplier: %s \n",name);
             
             if (s->idSupplier == s->currFur->idSup) /* Aqui me da el primer error de dereferencing  */
                       s->currFur->retailPrice = s->profitMargin * s->currFur->costPrice;
             while (s->currFur!=NULL)
                   {
                        fur_get_name(s->currFur,name); /* Aqui me da el error de incompatible tipo de argumento en parametro 1*/
                        printf("Furniture: %s \t",name);
                       
                        price=fur_get_retailPrice(s->currFur);
                        printf("Old retail price: %d \t", price);
                       
                        s->currFur->retailPrice = s->profitMargin * s->currFur->costPrice;
                       
                       
                        price=fur_get_retailPrice(s->currFur);
                        printf("New retail price: %d \n", price);
                       
                        s->currFur=s.currFur->nextFur;
                   }
             printf("-----------------------------------------------------------------");
        }
}

El caso es que me da el derreferencing ese tipico de las estructuras mal leidas pero es que he probado de todo y no se como solucinarlo. Si alguien me guiara en como acceder a la estructura, en las líneas marcadas con los comentarios, solo hay dos, le estaría enormemente agradecido. El resto ya las resolvería yo, por que son iguales.

Gracias.

Saludos.
Chema.