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

 

 


Tema destacado: Usando Git para manipular el directorio de trabajo, el índice y commits (segunda parte)


  Mostrar Mensajes
Páginas: [1] 2
1  Programación / Programación C/C++ / problema con funcion fecha en: 6 Marzo 2015, 21:45 pm
tengo esta funcion pero no encuentro el error

  main.cpp

Código
  1.      #include <iostream>
  2.        #include "clasehora.h"
  3.        using namespace std;
  4.  
  5.    int main()
  6.    {
  7.        Hora h1(),
  8.             h2(23,45,03),
  9.             h3(8, 8, 8);
  10.  
  11.        cout<< h1<<endl;
  12.        cout<<(h2+86520)<<endl;
  13.        cout<<(h2+3600)<<endl;
  14.        cout<< (--h2)<<endl;
  15.        cout<< (h2--)<<endl;
  16.        cout<< "h2-h3=" <<(h2-h3)<<endl; //
  17.        cout<< "h3-h2="<<(h3-h2)<<endl;
  18.  
  19.        cout<< h1<<endl;
  20.        cout<<(h2+86520)<<endl;
  21.        cout<<(h2+3600)<<endl;
  22.        cout<< (--h2)<<endl;
  23.        cout<< (h2--)<<endl;
  24.        cout<< "h2-h3=" <<(h2-h3)<<endl;
  25.        cout<< "h3-h2="<<(h3-h2)<<endl;
  26.        return 0;
  27.    }
  28.  
  29.        #include <iostream>
  30.        #include "clasehora.h"
  31.        using namespace std;
  32.  
  33.        Hora::Hora() //constructor por defecto
  34.        {
  35.            hora=0;
  36.            minutos=0;
  37.            segundos=0;
  38.        }
  39.        /*
  40.         Hora :: Hora(long h, long m,long s) //parametrizado
  41.         {
  42.             this->hora=h;
  43.             this->minutos=m;
  44.             this->segundo=s;
  45.         }
  46.         */
  47.  
  48.        /*
  49.         Hora :: Hora(const Hora &obj) //de copia
  50.         {
  51.             this->hora=obj.hora;
  52.             this->minutos=obj.minutos;
  53.             this->segundo=obj.segundo;
  54.         }
  55.        
  56.        
  57.         */
  58.  
  59.        /*
  60.         Hora::~Hora()
  61.         {
  62.             //dtor
  63.         }
  64.        
  65.         Hora::Hora(const unsigned hora, const unsigned minutos, const unsigned segundos)   //constructor por parametros
  66.         {
  67.             this->hora=hora;
  68.             minutos=m;
  69.             segundos=s;
  70.         }
  71.        
  72.         Hora::Hora(const Hora& obj)   //constructor de objeto
  73.         {
  74.             hora=obj.hora;
  75.             minutos=obj.minutos;
  76.             segundos=obj.segundos;
  77.        
  78.         }
  79.        
  80.        
  81.         */
  82.  
  83.  
  84.  
  85.  
  86.        Hora::Hora(int hora, int min, long seg) //pasa a segundos
  87.        {
  88.            segundos=(seg+min*60+hora*3600)%86400;
  89.            if(segundos<0)
  90.                segundos+=86400;
  91.        }
  92.  
  93.  
       
        metodos.cpp
        
        
Código
  1. Hora& Hora::operator--(void)
  2.        {
  3.            segundos--;
  4.            if(segundos<0)
  5.                segundos+=86400; //86400 son 24 horas
  6.            return *this;
  7.        }
  8.  
  9.        Hora Hora::operator--(int)
  10.        {
  11.            Hora aux(*this);
  12.            segundos--;
  13.            if(segundos<0)
  14.                segundos+=86400; //86400 son 24 horas
  15.            return aux;
  16.        }
  17.        Hora Hora::operator+(const int seg)const
  18.        {
  19.            Hora res(*this);
  20.            res.segundos+=seg;
  21.            if(res.segundos>86400) //86400 son 24 horas
  22.                res.segundos-=86400;
  23.            return res;
  24.        }
  25.  
  26.        long Hora::operator-(const Hora &obj)const
  27.        {
  28.            long res;
  29.            res=(this->segundos-obj.segundos);
  30.            if(res<0)
  31.                res+=86400;
  32.            return res;
  33.        }
  34.  
  35.        ostream& operator<<(ostream &sal, const Hora& obj) //para pasar de hh-mm-ss a am/pm
  36.        {
  37.            sal<< "HH-MM-SS"<<endl;
  38.            sal<< (obj.segundos/3600); //60*60->segundos pasados a horas
  39.            sal<<"-" <<(obj.segundos%3600)/60 << "-" <<((obj.segundos%3600)%60);
  40.            if((obj.segundos/3600)>11)
  41.                sal<<" PM"<< endl;
  42.            else
  43.                sal<<" AM" << endl;
  44.            return sal;
  45.        }
   
clasehora.h

Código
  1.  
  2.        #ifndef CLASEHORA_H_INCLUDED
  3.        #define CLASEHORA_H_INCLUDED
  4.  
  5.        #include <iostream>
  6.  
  7.        using namespace std;
  8.  
  9.        class Hora
  10.        {
  11.            long segundo;
  12.        public:
  13.            Hora();
  14.            Hora(int hora, int min, long seg);
  15.            Hora& operator--();           //pre
  16.            Hora operator--(int);         //pos
  17.            Hora operator+(const int seg)const;
  18.            long operator-(const Hora&obj)const;
  19.            friend ostream& operator<<(ostream &sal, const Hora &obj);
  20.        private:
  21.            long hora;
  22.            long minutos;
  23.            long segundos;
  24.        };
  25.  
  26.        #endif // CLASEHORA_H_INCLUDED

output correct

h2 son: 85503 segundos

h3 son: 29288 segundos

 h2-h3 es: 56215

 h2-h3 es: -56215

 h2+86520 es: 172023

 h2+3600 es: 89103

 --h2: 85502

 h2--: 85502

Mod: tema modificado, para hacer más legible tu código usa las etiquetas GeSHi
2  Programación / Programación C/C++ / Error en clase circulo en: 6 Marzo 2015, 19:44 pm
Hola gente, no encuentro el error, me dice "Circulo was not declared in this scope", pero creo que declare todo

main.cpp
#include <iostream>

using namespace std;
Código:
int main()
{
    //parametrizado
    Circulo c1(10.5, 20.0, 1, "Rojo Intenso"),c2, c3;

   c2 = c1--;    // decrementa, si se puede, el diámetro

    c3 = c2++;    // incrementa, si se puede, el diámetro

    Circulo c4 = c3++;

    c4.CambiarColor("Amarillo patito flúo");


    cout << c1 << c2 << c3 << (c4 = c3) << endl;

    return 0;
}

Circulo.cpp

Código:
#include "Circulo.h"
#include <string.h>

using namespace std;

Circulo :: Circulo() //por defecto
{
    x=0.0;
    y=0.0;
    diam=0;
    strcpy(Color,"");
}

Circulo::Circulo(float x,float y,unsigned diam,char *Color) //parametrizado
{
    this->x=x;
    this->y=y;
    this->diam=diam;
    this->Color= Color;
}

Circulo::Circulo(const Circulo& obj) //por copia
{
    this->x=obj.x;
    this->y=obj.y;
    this->diam=diam;
    this->Color=Color;
}

Circulo.h

Código:
#ifndef CIRCULO_H
#define CIRCULO_H
#include <iostream>

using namespace std;

class Circulo
{
    public:
        Circulo();
        Circulo(float x,float y,unsigned diam,char *Color);
        Circulo(const Circulo& obj);
    private:
        float x,y;
        unsigned diam;
        char *Color;

};

#endif // CIRCULO_H


3  Programación / Programación C/C++ / duda con recorridos en arbol en: 26 Febrero 2015, 01:49 am

Hola gente tengo una duda con árboles, luego de cargar un árbol y guardarlo en un archivo trato de recorrerlo, el recorrido inorden me anda bien pero los recorridos post y post orden me dan mal, en que estoy fallando?

Código:
#include <stdio.h>
#include <stdlib.h>

#define SIN_MEMORIA 0
#define CLAVE_DUPLICADA 0
#define TODO_BIEN 1
#define FALLO_ABRIR_ARCHIVO 0
#define NO_PUDO_GUARDAR_ARBOL 0
#define FALLO_CREAR_ARCHIVO 0

typedef struct
{
    int num;
}t_info;

typedef struct s_nodo
{   t_info info;
    struct s_nodo *der;
    struct s_nodo *izq;
}t_nodo;

typedef t_nodo* t_arbol;

int menu();
void crearArbol(t_arbol*);
int insertarNodoIterativo(t_arbol*, const t_info*);
int insertarNodoRecursivo(t_arbol*,const t_info*);
int compara(const t_info*,const t_info*);
void preorden(const t_arbol*);
void inorden (const t_arbol*);
void posorden(const t_arbol*);
void mostrar(const t_info*);
void grabarEnArchivo(t_arbol*,FILE*);
int guardarArbol(t_arbol*,FILE*);
int recuperarDeArchivo(t_arbol*,FILE*);
int contarNodos(t_arbol*);
int contarHojas(t_arbol*);
int contarHojasSubarbolDerecho(t_arbol*);
int contarNodosNoHojas(t_arbol*);
int contarNodosconHI(t_arbol*);
int contarHSI(t_arbol*);
int contarPadresSoloCHI(t_arbol*);
int contarNodosMayoresYPares(t_arbol*);
t_nodo* buscarNodo(t_arbol*, const t_info*);
int eliminarHojas(t_arbol*);
void eliminarArbol(t_arbol*);
int eliminarHojasConClave(t_arbol*, const t_info*);
int eliminarSubArbolConClave(t_arbol*, const t_info*);
float promedioArbol(t_arbol*,int*);
int mostrarNoHojas(t_arbol *);


int main()
{
    t_arbol raiz;
    t_info d;
    int opcion;
    t_info clave;
    FILE* pf;
    int sum=0;

     //crearArbol(&raiz);
    while((opcion=menu())!=0)
    {
        switch(opcion)
        {
                case 1:

                        crearArbol(&raiz);
                        printf("Arbol creado correctamente \n");
                        break;
                case 2:

                      printf("Ingresar de forma Iterativa...\n");
                      printf("Ingrese un mumero:\n");
                      scanf("%d",&d.num);
                      if(insertarNodoIterativo(&raiz,&d))
                        printf("Inserto Nodo Correctamente\n");
                      else
                        printf("No se pudo insertar en arbol\n");
                    break;
                case 3:
                       printf("Ingresar de forma Recursiva...\n");
                       printf("Ingrese un mumero:\n");
                       scanf("%d",&d.num);
                       if(insertarNodoRecursivo(&raiz,&d))
                            printf("Inseto Nodo Correctamente\n");
                       else
                         printf("No se pudo insertar en arbol\n");
                    break;
                case 4:
                        printf("Mostrar en preorden...\n");
                        preorden(&raiz);
                        if(raiz==NULL)
                            printf("Arbol Vacio\n");
                        break;

                case 5:
                    printf("Mostrar en inOrden...\n");
                    inorden(&raiz);
                    printf("\n");
                    break;

                case 6:
                    printf("Mostrar en posOrden...\n");
                    posorden(&raiz);
                    break;

                case 7:
                    //if(!(pf=fopen("ArchivoArbol","rb")))
                        if(!(pf=fopen("ArchivoArbol1","wb")))
                            return FALLO_CREAR_ARCHIVO;
                    printf("**************** Guardar el Arbol en Archivo *********************\n");
                    if(guardarArbol(&raiz,pf)==0)
                        printf("No pudo guardar Arbol\n");
                    else
                        printf("Arbol Guardado Correctamente\n");


                        fclose(pf);
                break;

                case 8:
                    crearArbol(&raiz);
                    printf("Recuperar el Arbol de Archivo\n");
                    if(!(pf=fopen("ArchivoArbol1","rb")))
                      return FALLO_ABRIR_ARCHIVO;
                    if(!recuperarDeArchivo(&raiz,pf))
                        printf("No se pudo recuperar datos del arbol\n\n");
                    fclose(pf);
                break;

                case 9:
                    printf("************ CONTAR NODOS ******************\n");
                    printf("Cantidad de nodos en el arbol: %d\t\n\n", contarNodos(&raiz));
                    break;

                case 10:
                    printf("************ CONTAR HOJAS *******************\n");
                    printf("Cantidad de hojas en el arbol: %d\t\n\n", contarHojas(&raiz));
                    break;

                case 11:
                    printf("Hojas del subarbol derecho: %d\t\n\n", contarHojasSubarbolDerecho(&raiz));
                    break;

                case 12:
                    printf("Contar nodos no Hojas\n");
                    printf("Nodos no hojas: %d\t\n\n", contarNodosNoHojas(&raiz));
                    break;

                case 13:
                    printf("***************** Contar nodos con Hijos Izquierda ****************\n");
                    printf("Nodos con hijos a la izquierda: %d\t\n\n", contarNodosconHI(&raiz));
                    break;

                case 14:
                    printf("***************** Contar hijos solo a la izquierda *****************\n");
                    printf("Hijos a la izquierda: %d\t\n\n", contarHSI(&raiz));
                    break;

                case 15:
                    printf("********** Padres con hijos solo a la izquierda *********************\n");
                    printf("Padres con hijos solo a la izquierda: %d\t\n\n", contarPadresSoloCHI(&raiz));
                    break;

                case 16:
                    printf("************* Nodos Pares y Mayores a 50 ****************************\n");
                    printf("Nodos pares y mayores a 50: %d\t\n\n", contarNodosMayoresYPares(&raiz));
                    break;

                case 17:
                    printf("******** Buscar por una clave dada y retornar direccion **************\n");
                    printf("Ingrese la clave de busqueda: ");
                    scanf("%d",&d);
                    printf("La direccion de la clave %d es %p\n", d,buscarNodo(&raiz,&d));

                case 18:
                    printf("************* Eliminar las hojas **********************************\n");
                    printf("Hojas eliminadas: %d\t\n", eliminarHojas(&raiz));
                    break;

                case 19:
                    printf("******************** Eliminar Arbol ********************************\n");
                    eliminarArbol(&raiz);
                    break;

                case 20:
                    printf("*********** Eliminar hojas a partir de una clave *******************\n");
                    printf("Ingrese la clave: ");
                    scanf("%d", & d);
                    printf("Se eliminaron %d hojas\t\n", eliminarHojasConClave(&raiz,&d));
                    break;

                case 21:
                    printf("************ Eliminar Subarbol a partir de una clave *****************\n");
                    printf("Ingrese la clave: ");
                    scanf("%d", & d);
                    printf("Se eliminaron %d nodos del subArbol desde la clave %d", eliminarSubArbolConClave(&raiz,&d), d);
                    break;

                case 22:
                    printf("***************** Promedio del Arbol *******************************)");
                    printf("el promedio del Arbol es: %f", (float)sum/promedioArbol(&raiz,&sum));
                    break;
                case 23:
                    printf("***************** Mostrar No Hojas *******************************)");
                    printf("Mostrar no nodos en el arbol: %d\t\n\n", mostrarNoHojas(&raiz));
                    break;
        }

    }
   //fclose(pf);
return 1;
}
////////////////////////////////////////
int menu(void)
{
    int opcion;
    do{
        printf("1 -  Crear Arbol \n");
        printf("2 -  Insertar Nodo Iterativo \n");
        printf("3 -  Insertar Nodo Recursivo \n");
        printf("4 -  Recorrido PREORDEN \n");
        printf("5 -  Recorrido INORDEN \n");
        printf("6 -  Recorrido POSORDEN \n");
        printf("7 -  Guardar el Arbol a un Archivo \n");
        printf("8 -  Recuperar el Arbol desde un Archivo \n");
        printf("9 -  Contar Nodos\n");
        printf("10-  Contar Hojas\n");
        printf("11-  Contar Hojas sub Arbol Derecho\n");
        printf("12-  Contar Nodos no Hojas\n");
        printf("13-  Contar Nodos con Hijos a la izquierda\n");
        printf("14-  Contar hijos solo a la izquierda\n");
        printf("15-  Contar Padres con Hijos solo a la izquierda\n");
        printf("16-  Contar nodos pares y mayores a 50\n");
        printf("17-  Buscar por una clave dada\n");
        printf("18-  Eliminar las hojas\n");
        printf("19-  Eliminar Arbol\n");
        printf("20-  Eliminar hojas a partir de una clave\n");
        printf("21-  Eliminar un SubArbol a partir de una clave\n");
        printf("22-  Promedio del Arbol\n");
        printf("23-  Mostrar no hojas\n");

        printf("0-  Salir \n");
        scanf("%d",&opcion);

    }while(opcion<0&&opcion>22);
    //system("cls");
}
//////////////////////////////////////////////////
void crearArbol(t_arbol*p)
{
    *p=NULL;
}
//////////////////////////////////
int insertarNodoIterativo(t_arbol* p, const t_info *d)
{int cmp;
    while(*p)
    {
        if((cmp=compara(d,&(*p)->info))==0)
           return CLAVE_DUPLICADA;
         if(cmp<0)
            p=&(*p)->izq;
         else
            p=&(*p)->der;

    }
    ///poner en nodo
    *p=(t_nodo*) malloc(sizeof(t_nodo));
    if(!(*p))
        return SIN_MEMORIA;
    (*p)->info=*d;
    (*p)->izq=(*p)->der=NULL;
    return TODO_BIEN;
}
///////////////////////////////////////
int insertarNodoRecursivo(t_arbol* p, const t_info*d)
{int cmp;
    if(*p)
    {
       if((cmp=compara(d,&(*p)->info))==0)
           return CLAVE_DUPLICADA;
           if(cmp<0)
                insertarNodoRecursivo(&(*p)->izq,d);
           else
                insertarNodoRecursivo(&(*p)->der,d);
    }
    else
    {
           //poner en nodo
        *p=(t_nodo*) malloc(sizeof(t_nodo));
        if(!(*p))
            return SIN_MEMORIA;
        (*p)->info=*d;
        (*p)->izq=(*p)->der=NULL;
        return TODO_BIEN;
    }

}
///////////////////////////////////
int compara(const t_info* d,const t_info* p )
{
    if(d->num < p->num)
        return -1;
    if(d->num > p->num)
        return 1;
    return 0;
}
/////////////////////////////////////
void preorden(const t_arbol *p)
{
    if(*p)
    {
        mostrar(&(*p)->info);
        preorden(&(*p)->izq);
        preorden(&(*p)->der);
    }
}
///////////////////////////////
void inorden(const t_arbol*p)
{
    if(*p)
    {
        inorden(&(*p)->izq);
        mostrar(&(*p)->info);
        inorden(&(*p)->der);
    }
}
//////////////////////////////////////
void posorden(const t_arbol*p)
{
    if(*p)
    {
        posorden(&(*p)->izq);
        posorden(&(*p)->der);
        mostrar(&(*p)->info);
    }
}
//////////////////////////////
void mostrar(const t_info* p)
{
    //mostrar(&(*p)->izq);
    printf("%d\t",p->num);
    printf("\n");
    //mostrar(&(*p)->der);
}

///////////////////////////////////////////////
void grabarenArchivo(t_arbol* p ,FILE* pf)
{
    fwrite(&(*p)->info.num,sizeof(t_info),1,pf);
}

////////////////////////////////////////////////////
int guardarArbol(t_arbol* p, FILE* pf)
{
    //printf("Grabo correctamente\n");
    if(*p)
    {
        grabarenArchivo(p,pf);
        guardarArbol(&(*p)->izq,pf);
        guardarArbol(&(*p)->der,pf);
        return 1;
    }
    return 0;
}

//////////////////////////////////////////////////////////////////
int recuperarDeArchivo(t_arbol* p, FILE* pf)
{
    t_info aux;
    fread(&aux,sizeof(t_info),1,pf);
    while(!feof(pf))
    {
       if(insertarNodoIterativo(p,&aux))
            fread(&aux,sizeof(t_info),1,pf);
        else
            return 0;
    }
    return 1;
}

///////////////////////////////////////////////////////////////////////

int contarNodos(t_arbol* p)
{
    if(*p)
        return 1+ contarNodos(&(*p)->izq) + contarNodos(&(*p)->der);
    return 0;
}
/*
int contarHojas(t_arbol* p)
{
    if(*p)
    {
        if((*p)->izq==NULL && (*p)->der==NULL)
            return 1;
        return contarHojas(&(*p)->izq)+ contarHojas(&(*p)->der);
    }
    return 0;
}
*/

int contarHojas(t_arbol *p)
{
    if(!*p)
        return 0;
    return (((*p)->izq==NULL)&&((*p)->der==NULL))?1:0+contarHojas(&(*p)->izq == NULL)+contarHojas(&(*p)->der);
}
///////////////////////////////////////////////////////////////////////

int contarHojasSubarbolDerecho(t_arbol* p)
{
    if(*p)
        return contarHojas(&(*p)->der);
}

int contarNodosNoHojas(t_arbol* p)
{
    if(!(*p))
        return 0;
    if((*p)->izq ||(*p)->der)
        return 1+contarNodosNoHojas(&(*p)->izq)+contarNodosNoHojas(&(*p)->der);
    return 0;
}

int contarNodosconHI(t_arbol* p)
{
    if(!(*p))
        return 0;
    if((*p)->izq)
        return contarNodosconHI(&(*p)->izq)+contarNodosconHI(&(*p)->der)+1;
    return contarNodosconHI(&(*p)->der);
}

int contarHSI(t_arbol* p)///Hijos a la izquierda y no tienen hijos a la derecha
{
    if(!(*p))
        return 0;
    return contarHSI(&(*p)->izq)+contarHSI(&(*p)->der)+(((*p)->izq) && !(*p)->der)?1:0;
}

int contarPadresSoloCHI(t_arbol* p)
{
    if(!(*p))
        return 0;
    return contarPadresSoloCHI(&(*p)->izq)+contarPadresSoloCHI(&(*p)->der)+((*p)->izq && !(*p)->der)?1:0;
}

int contarNodosMayoresYPares(t_arbol* p)
{
    if(*p)
    {
        return contarNodosMayoresYPares(&(*p)->izq) + contarNodosMayoresYPares(&(*p)->der) + (((*p)->info.num)>50 && (((*p)->info.num)%2==0)?1:0);
    }
    return 0;
}

t_nodo* buscarNodo(t_arbol* p, const t_info* d)
{
    int cmp;
    if(*p)
    {
        if((cmp=compara(d,&(*p)->info))==0)
            return *p;
        if(cmp<0)
            return buscarNodo(&(*p)->izq,d);
        else
            return buscarNodo(&(*p)->der,d);
    }
    return NULL;
}

int eliminarHojas(t_arbol* p)
{
    if(*p)
    {
        if(!(*p)->izq && !(*p)->der)//if((*p)->izq == (*p)->der)
        {
            free(*p);
            *p=NULL;
            return 1;
        }
        return eliminarHojas(&(*p)->izq)+eliminarHojas(&(*p)->der);
    }
}
void eliminarArbol(t_arbol* p)
{
    if(*p)
    {
        eliminarArbol(&(*p)->izq);
        eliminarArbol(&(*p)->der);
        free(*p);
        *p=NULL;
    }
}

int eliminarHojasConClave(t_arbol* p, const t_info* d)
{
    int cmp;
    if(*p)
    {
        cmp=compara(d,&(*p)->info);
        if(cmp==0)
        {
            return eliminarHojas(&(*p)->izq)+eliminarHojas(&(*p)->der);
        }
        if(cmp<0)
            return eliminarHojasConClave(&(*p)->izq,d);
        else
            return eliminarHojasConClave(&(*p)->der,d);
    }
    return 0;
}

int eliminarSubArbolConClave(t_arbol* p, const t_info* d)
{
    t_nodo* nodo;
    if(nodo=buscarNodo(p,d))
    {
       eliminarArbol(&(*nodo).izq);
       eliminarArbol(&(*nodo).der);
       ///eliminarArbol(nodo);
       return 1;
    }
     return 0;
}

/*float promedioArbol(t_arbol* p)
{
    int cont=0;

    int acum=0;
    if(*p)
    {
       cont=sumaracumulararbol(p,&acum);
       return (float) acum/cont;
    }
    return 0;
    *p==NULL;
}

int sumaracumulararbol(t_arbol* p,int* acum)
{
    if(*p)
    {
        printf("%d\n",(*p)->info.num);
        (*acum)+=(*p)->info.num;
        return 1 + sumaracumulararbol(&(*p)->izq,acum)+sumaracumulararbol(&(*p)->der,acum);

        printf("%d: ",acum);

    }
    return 0;
}
*/

float promedioArbol(t_arbol* p,int* sum)
{
    if(*p)
    {
        return promedioArbol(&(*p)->izq,sum)+((*p)->izq?1:0);
            if((*p)->izq)
                *sum+=(*p)->info.num;

        return promedioArbol(&(*p)->der,sum)+((*p)->der?1:0);
            if((*p)->der)
                *sum+=(*p)->info.num;
    }
    return 0;
}

int mostrarNoHojas(t_arbol *p)
{
    int aux=0;
    if(*p==NULL)
        return;
    if((*p)->izq != NULL || (*p)->der !=  NULL)
    {
        printf("%d",(*p)->info.num);
        aux++;
    }
    aux += mostrarNoHojas(&((*p)->izq));
    aux += mostrarNoHojas(&((*p)->der));
    return aux;
}
/*
int eliminarHojas(t_arbol *p)
{
    if(*p)
        return 0;
    if(!(*p)->izq && !(*p)->der )
    {
        free(*p);
        *p=NULL;
        return 1;
    }
    else
    {
      return   eliminarHojas(&(*p)->izq) + //elimina y cuenta
        eliminarHojas(&(*p)->der);
    }
}
*/
/*
void eliminarArbol(t_arbol *p)
int eliminarArbol(t_arbol *p) //para contar
{
    int aux=0;
    if(!*p)

        return;
      (eliminarArbol(&(*p)->izq)+eliminarArbol(&(*p)->der)+1);
     free(*p);

}
*/
/*

int eliminarArbol(t_arbol *p) //para contar
{
    int aux=0;
    if(!*p)

        return 0;
      aux+=eliminarArbol(&(*p)->izq);
      aux+=eliminarArbol(&(*p)->der);
     free(*p);
     *p=NULL;
     return aux;

}
*/

/*
int altura(t_arbol*p)
{
    int hd,hi;
    if(!*0)
        return 0; //0 nivel , 1 altura
    hd=altura(&(*p)->der);
    hi=altura(&(*p)->izq);
    return hd>hi?hd+1:hi+1;0
}
*/

4  Programación / Programación C/C++ / Error al grabar en estructuras en: 19 Febrero 2015, 22:16 pm
Hola tengo el siguiente enunciado:

Archivo de Recetas: contiene el código de receta (númerico de 1 a 50),
el número de registro de donde se encuentra el ingrediente que forma la receta y
la cantidad necesaria de ese ingrediente para preparar la receta.
El archivo esta ordenado por código de receta. Una receta tiene uno o más ingredientes.

Archivo de Ingredientes: indica el nombre del ingrediente (alfabético de 15 elementos),
el stock actual de dicho ingrediente y el costo de cada unidad en stock.
(NO debe suponer que siempre hay stock suficiente para atender una receta).

y tengo la codificación:
Código:
#include <stdio.h>
#define TAM 10
#define MSG 1

typedef struct
{
   int codReceta;
   int nroRegIngr[30]; //vector de ingredientes
   int cantIngr[30];  //vector de cantidad de ingredientes
   int cantRegIngr;
}t_receta;

typedef struct  //estructura de ingredientes
{
    char nroRegIngr;
    char nomIngr[16];
    int  stock;
    float precio;
}t_ingrediente;

int main()
{
    FILE *rece;
    FILE *pingre;
    if(!abrirArchivo(&rece,"recetas.bin","rb",MSG))
        return 1;
    if(!abrirArchivo(&pingre,"ingredientes.bin","rb",MSG))
    {
        fclose(pingre);
        return 2;
    }

    if(rece)
    {
        int conta=1;
        while (!feof(rece))
        {
            ///procesar recetas

        }
    }
    else
    {
        puts("imposible abrir archivo");
    }

    return 0;
}



void CrearArchivo()
{
    FILE *prec=fopen("recetas.bin","wb");
    FILE *pingre=fopen("ingredientes.bin","wb");
    t_receta re []={{1,3,4,4 },
                    {2,4,5,5 }};

    t_receta re2[]={{1,"harina",4.0 },
                    {2,"huevo",4.0 },
                    };


    if(prec!=NULL )
    {
        fwrite(re, sizeof(re),1,prec);
        fclose(prec);
    }

    if(pingre!=NULL)
    {
        fwrite(re, sizeof(re2),1,pingre);
        fclose(pingre);
    }
}

en que estoy fallando?
5  Programación / Programación C/C++ / No crea un nuevo archivo de personas del sexo femenino en: 16 Febrero 2015, 15:58 pm
El programa debe mostrar, en un archivo nuevo, todos los registros de sexo femenino que habian sido apilados mientras leia el archivo binario original y sacados de pila para ser guardados en el nuevo archivo.
Pero no me graba el archivos Femeninas y me muestra mal, que puede ser?

main.c
Código:
#include <stdio.h>
#include <stdlib.h>
#include "dinamica.h"
#define MSG 1

void crearArchivo();
int abrirArchivo(FILE **, const char *, const char *, int);
void mostrarArchivo(FILE*);


int main()
{
    FILE *fpBin,
         *fpFem;
    t_info reg;
    t_pila pila;

    crearArchivo(fpBin);
    crearPila(&pila);
    if(!abrirArchivo(&fpBin, "Datos.bin", "rb", MSG))
        return 1;
    printf("\n \n \t \t \t ARCHIVO ORIGINAL \n");
    mostrarArchivo(fpBin);
    rewind(fpBin);
    fread(&reg, sizeof(t_info), 1, fpBin);
    while(!feof(fpBin))
    {
        if(reg.sex=='F' && !pilaLLena(&pila))
        {
            apilar(&pila, &reg);
            printf("%s \n", reg.ape);
        }
        fread(&reg, sizeof(t_info), 1, fpBin);
    }
    fclose(fpBin);

    if(!abrirArchivo(&fpFem, "Femeninas", "w+b", MSG))
        return 1;
    while(!pilaVacia(&pila))
    {
        sacarDePila(&pila, &reg);
        printf("%s \n", reg.ape);
        fwrite(&reg, sizeof(t_info), 1, fpFem);
    }
    rewind(fpFem);
    printf("\n \n \t \t \t ARCHIVO FEMENINO \n");
    mostrarArchivo(fpFem);
    fclose(fpFem);
    return 0;
}

//////funciones
void crearArchivo(void)
{
    FILE *fp = fopen("Datos.bin", "wb");
    t_info reg[] = {{111, "Palacio", "Rocio", 'F'},
        {222, "Sa", "Lia", 'F'},
        {333, "Perez", "Roberto", 'M'},
        {444, "Sanchez", "Lara", 'F'},
        {555, "Castillo", "Luis", 'M'}
    };

    if(fp!=NULL)
        fwrite(&reg, sizeof(t_info), 5, fp);
    fclose(fp);
}
////
int abrirArchivo(FILE **fp, const char *nombre, const char * modo, int msg)
{
    *fp = fopen("Datos.bin", "rb");
    if(*fp==NULL && msg)
    {
        printf("error abriendo archivo \n");
        return 0;
    }
    return 1;
}
/////
void mostrarArchivo(FILE*fp)
{
    t_info reg;
    printf("DNI \t Apellido \t Nombre \t Sexo \n");
    fread(&reg, sizeof(reg), 1, fp);
    while(!feof(fp))
    {
        printf("%d \t %s \t %s \t \t%c \n", reg.dni, reg.ape, reg.nombre, reg.sex);
        fread(&reg, sizeof(reg), 1, fp);
    }
}
////

dinamica.h

Código:
#ifndef DINAMICA_H_INCLUDED
#define DINAMICA_H_INCLUDED

typedef struct
{
    int dni;
    char ape[30],
         nombre[30],
         sex;
} t_info;

typedef struct s_nodo
{
    t_info info;
    struct s_nodo *sig;
} t_nodo;

typedef t_nodo* t_pila;

void crearPila(t_pila *);
int apilar(t_pila *, const t_info *);
int verTope(const t_pila *, t_info *);
int sacarDePila(t_pila *, t_info *);
int pilaLLena(const t_pila *);
int pilaVacia(const t_pila *);
void vaciarPila(t_pila *);

/////FUNCIONES
void crearPila(t_pila *p)
{
    *p = NULL;
}
/////
int apilar(t_pila *p, const t_info *d)
{
    t_nodo * nue= (t_nodo*)malloc(sizeof(t_nodo));
    if(nue==NULL)
        return 0;
    nue->info=*d;
    nue->sig=*p;
    *p=nue;
    return 1;
}
/////
int pilaLLena(const t_pila *p)
{
    t_nodo *aux = (t_nodo*)malloc(sizeof(t_nodo));
    free(aux);
    return aux==NULL;
}
/////
int pilaVacia(const t_pila *p)
{
    return *p==NULL;
}
/////
int verTope(const t_pila *p, t_info *d)
{
    if(*p==NULL)
        return 0;
    *d = (*p)->info;
    return 1;
}
/////
int sacarDePila(t_pila *p, t_info *d)
{
    t_nodo *aux;
    if(*p==NULL)
        return 0;
    aux=*p;
    *d =aux->info;
    *p=aux->sig;
    free(aux);
    return 1;
}
/////
void vaciarPila (t_pila *p)
{
    t_nodo *aux;
    while(*p)
    {
        aux=*p;
        *p=aux->sig;
        free(aux);
    }
}

#endif // DINAMICA_H_INCLUDED





6  Programación / Programación C/C++ / dividir un archivo binario en 3 en: 16 Febrero 2015, 13:10 pm
Hola gente una pregunta, en el enunciado dice "que divida en tres nuevos archivos binarios (<"archal1">, <"archal2"> y
<"archal3">) el archivo anterior, tomado los primeros 30 para el primer archivo, los
siguientes 30 para el segundo y los restantes para el tercero."
Yo pense hacer lo con:

Código:
fseek(pf,29,0)
//va del principio a la posicion 29
Código:
fseek(pf,51,1)
//de la posicion actual a la 59
Código:
fseek(pf,60,2)
//de la 60 hasta que termine el archivo
tengo duda para grabar los demas archivos, como hago? están bien los fseek?
de base voy a usar la siguiente codificacion:

Código:
#‎include‬ <stdio.h>
#include <stdlib.h>
‪#‎define‬ MSG 1

int abrir_archivo (FILE**, char *, char *, int);
void mostrarReg(vect);

int main(void)
{
int i;
int vect;
FILE *archi;
archi=fopen("archalea.dat","w+b");
if(!archi)
{
puts("imposible abrir archivo");
}
else
{
 printf("90 numeros aleatorios del 0 al 99\n\n");
 for(i=0; i<89; i++)
 {
    vect=rand() % 1000;
   fwrite(&vect,sizeof(vect),1,archi);
 }
fclose(archi);

archi=fopen("archalea.dat","r+b");
if(archi)
{
int conta=0;
while (!feof(archi))
{

printf("\n posicion= %d Numero : %d", conta+1,vect);
conta++;
fread(&vect, sizeof(vect),1, archi);
//acá tengo que poner los fseek?
}
}
else
{
puts("imposible abrir archivo");
}

}
close(archi);
printf("\n");
return 0;
}
7  Programación / Programación C/C++ / Mostrar la cantidad de veces que una cadena se repite en: 8 Febrero 2015, 11:42 am
Hola, tengo esta codificación que Mostrar la cantidad de veces que una cadena se repite en otra cadena, pero quiero que me tome en cuenta los espacios en balnco entre cada caracter, así esta línea
Código:
printf ("\n La cadena 5 se repite %d veces en la cadena 4",cantrepeticiones(cad4,cad5));
muestre
Código:
La cadena 5 se repite 1 veces en la cadena 4"
pero me muestra esto :
Código:
La cadena 5 se repite 0 veces en la cadena 4

Código:
#include <stdio.h>
#include <stdlib.h>
#define aMayusc(X)((X)>='a'&&(X)<='z'?(X)-32:(X))

int cantrepeticiones (char*,char*);

int main()
{
    char cad1[]= "ananana";
    char cad2[]= "ana";
    char cad3[]= "an";
    printf ("\n");
    char cad4[]= "mariamariamariamariana";
    char cad5[]= "maria jose";
    char cad6[]= "maria";
    puts(cad1);
    puts(cad2);
    puts(cad3);
    puts(cad4);
    puts(cad5);
    puts(cad6);
    printf ("\n La cadena 2 se repite %d veces en la cadena 1",cantrepeticiones(cad1,cad2));
    printf ("\n La cadena 3 se repite %d veces en la cadena 1",cantrepeticiones(cad1,cad3));
    printf ("\n La cadena 5 se repite %d veces en la cadena 4",cantrepeticiones(cad4,cad5));
    printf ("\n La cadena 6 se repite %d veces en la cadena 4",cantrepeticiones(cad4,cad6));
    printf ("\n");
    return 0;
}

int cantrepeticiones(char* c1, char* c2)
{
    int repeticiones=0;
    char* coindicencia=c1;  //Para guardar la posicion donde encuentra coincidencia con el primer caracter de la cadena a buscar
    char* inicio=c2; // Para poder volver al inicio de la cadena a buscar, en caso de no encontrarla completa
    while (*c1)
    {
        if (aMayusc(*c1)==aMayusc(*c2))
        {
            coindicencia=c1; //Guardo la posicion de la primera coincidencia
            while (*c1 && *c2 && aMayusc(*c1)==aMayusc(*c2))
            {
                c1++;
                c2++;
            }
            if (!*c2)
                repeticiones+=1;
            c1=coindicencia; // Vuelvo a la posicion de la primera coincidencia de caracteres
            c2=inicio; //Vuelvo al inicio del a cadena a buscar, por que el puntero quedo en el \0 o en la posicion donde no hubo coincidencia
        }
        c1++;
    }
    //printf("\n %d",repeticiones);
    return repeticiones;
}

8  Programación / Programación C/C++ / Programa no cierra en: 7 Febrero 2015, 18:04 pm
Hola gente, el siguiente programa me funciona correctamente pero no sale, no me tira errores ni warnings, se "congela" el programa, que puede ser?

Código:
#include <stdio.h>
#include <stdlib.h>

#define esBlanco(x)((x)==' '||(x)=='\t')
#define aMayusc(x)((x)>='a'&&(x)<='z'?(x)-32:(x))
#define aMinusc(x)((x)>='A'&&(x)<='Z'?(x)+32:(x))

char* normalizar (char *);
char* normalizar2 (char *);
char* normalizar3 (char *);
char* normalizar4 (char *);

int main()
{
    char cad1[100]={"\t UN\teJEmPlo   ADeCUAdo\t  "};
char cad11[100]={"\t                UN\teJEmPlo   aDeCUAdo  "};
char cad12[100]={"\t                UN EJEMPLO   ADECUADO  "};
    char cad2[100]={"   "};
    char cad3[100]={"\tUufFFc Jf \t\t  "};
char cad31[100]={"\tUUUUUfff JfeY78u \t\t  "};
    printf("\"%s\"\n",normalizar(cad1));
printf("\"%s\"\n",normalizar(cad11));
printf("\"%s\"\n",normalizar(cad12));
    printf("\"%s\"\n",normalizar(cad2));
    printf("\"%s\"\n",normalizar(cad3));
printf("\"%s\"\n",normalizar(cad31));
printf("\n ----------------------------------------------------------------------------\n");
char cad4[100]={"\t UN\teJEmPlo   ADeCUAdo\t  "};
    char cad5[100]={"   "};
    char cad6[100]={"\tUufFFc Jf \t\t  "};
printf("\"%s\"\n",normalizar2(cad4));
    printf("\"%s\"\n",normalizar2(cad5));
    printf("\"%s\"\n",normalizar2(cad6));
    printf("\n ----------------------------------------------------------------------------\n");
    char cad7[100]={"\t UN\teJEmPlo   ADeCUAdo\t  "};
    char cad8[100]={"   "};
    char cad9[100]={"\tUufFFc Jf \t\t  "};
    printf("\"%s\"\n",normalizar3(cad7));
    printf("\"%s\"\n",normalizar3(cad8));
    printf("\"%s\"\n",normalizar3(cad9));
    printf("\n ----------------------------------------------------------------------------\n");
    char cad101[100]={"\t UN\teJEmPlo   ADeCUAdo\t  "};
    char cad111[100]={"   "};
    char cad121[100]={"\tUufFFc Jf \t\t  "};
    printf("\"%s\"\n",normalizar4(cad101));
    printf("\"%s\"\n",normalizar4(cad111));
    printf("\"%s\"\n",normalizar4(cad121));
    printf("\n");
    return 0;
}

char * normalizar (char * cad)
{
    char*pe,*pl; //puntero escritura, puntero lectura
    pe=pl=cad;
    while(*pl)
    {
        while(esBlanco(*pl)&&*pl)
            pl++;
        if(*pl)
        {
            *pe=aMayusc(*pl);
            pe++;
            pl++;
            while(*pl&&!esBlanco(*pl))
            {
                *pe=aMinusc(*pl);
                pe++;
                pl++;
            }
            if(esBlanco(*pl))
            {
                *pe=' ';
                pe++;
                pl++;
            }
        }
    }
    if(pe>cad) //eliminar el ultimo blanco, si todos fueran blancos no retrocede
         pe--;
    *pe='\0';
    return cad;
}

char * normalizar2 (char * cad)
{
    char*pe,*pl; //puntero escritura, puntero lectura
    pe=pl=cad;
    while(*pl)
    {
        while(esBlanco(*pl)&&*pl)
            pl++;
        if(*pl)
        {
            *pe=aMinusc(*pl);
            pe++;
            pl++;
            while(*pl&&!esBlanco(*pl))
            {
                *pe=aMinusc(*pl);
                pe++;
                pl++;
            }
            if(esBlanco(*pl))
            {
                *pe=' ';
                pe++;
                pl++;
            }
        }
    }
    if(pe>cad) //eliminar el ultimo blanco, si todos fueran blancos no retrocede
         pe--;
    *pe='\0';
    return cad;
}


char * normalizar3 (char * cad)
{
    char*pe,*pl; //puntero escritura, puntero lectura
    pe=pl=cad;
    while(*pl)
    {
        while(esBlanco(*pl)&&*pl)
            pl++;
        if(*pl)
        {
            *pe=aMayusc(*pl);
            pe++;
            pl++;
            while(*pl&&!esBlanco(*pl))
            {
                *pe=aMayusc(*pl);
                pe++;
                pl++;
            }
            if(esBlanco(*pl))
            {
                *pe=' ';
                pe++;
                pl++;
            }
        }
    }
    if(pe>cad) //eliminar el ultimo blanco, si todos fueran blancos no retrocede
         pe--;
    *pe='\0';
    return cad;
}

char * normalizar4 (char * cad)
{
    char*pe,*pl; //puntero escritura, puntero lectura
    pe=pl=cad;
    while(*pl)
    {
        int bande=0;
        while(esBlanco(*pl)&&*pl)
            pl++;
        if(*pl && bande==1)
        {
            *pe=aMayusc(*pl);
            pe++;
            pl++;
            while(*pl&&!esBlanco(*pl))
            {
                *pe=aMinusc(*pl);
                pe++;
                pl++;
            }
            if(esBlanco(*pl))
            {
                *pe=' ';
                pe++;
                pl++;
            }
        }
        //bande++;
    }
    if(pe>cad) //eliminar el ultimo blanco, si todos fueran blancos no retrocede
         pe--;
    *pe='\0';
    return cad;
}
9  Programación / Programación C/C++ / duda con ejercicio de matrices en: 6 Febrero 2015, 22:47 pm
Hola, tengo la siguiente codificación, debe calcular las diagonales principal y secundaria, el triángulo superior y la traza, no sé porqué pero no me acumula la variable de traza, qie puede ser?

Código:
#include <stdio.h>
#include <conio.h>

#define fil 2
#define col 2

int menu();
int * cargar_mat (int[fil][col],int* );
void mostrar_DP (int [fil][col]);
void mostrar_DS (int [fil][col]);
void mostrar_TS (int [fil][col]);
void mostrar_TR (int [fil][col]);

int main()
{
    int opc,mat[fil][col],cantElem=0;
    cargar_mat(mat,&cantElem);
    printf("\t escoja una opcion:");
    opc=menu();
    while(opc!=0)
    {
        switch(opc)
        {
        case 1:
        {
            mostrar_DP(mat);
            printf("\n");
            //printf("elementos:%d\n",cantElem);
        }
        break;
        case 2:
        {
            mostrar_DS(mat);
            printf("\n");
        }
        break;
        case 3:
        {
            mostrar_TS(mat);
            printf("\n");
        }
        case 4:
        {
            mostrar_TR(mat);
            printf("\n");
        }
        default:
        {

        } break;
        }
        printf("\t escoja una opcion:\n");
        opc=menu();
    }
    printf("\n");
    return 0;
}

int * cargar_mat (int mat[fil][col],int* cantE)
{
    int i,j;
    for(i=0; i<fil; i++)
    {
        for(j=0; j<col; j++)
        {
            printf("ingrese un numero: ");
            scanf("%d",&mat[i][j]);
            if(mat[i][j]==0)
                return  cantE;
            else
                (*cantE)++;
        }
    }
}


int menu()
{
    int opc;
    printf("\n");
    printf("\n1_ver diagonal principal\n2_ver diagonal secundaria\n3_triangulo superior\n4_traza\n0_salir\n");
    scanf("%d",&opc);
    printf("\n");
    return opc;
}

void mostrar_DP (int m[fil][col])
{
    int i;
    for(i=0; i<fil; i++)
        printf("%d\n",m[i][i]);
}


void mostrar_DS (int m[fil][col])
{
    int i;
    for(i=0; i<fil; i++)
        printf("%d\n",m[i][(col-1)-i]);
}

void mostrar_TS (int m[fil][col])
{
    int i;
    for(i=0; i<fil; i++)
        printf("%d\n",m[i][i]);
}

void mostrar_TR (int m[fil][col])
{
    int i;
    int acu=0;
    for(i=0; i<fil; i++)
    {
        acu+=m[i][i];
        printf("%d\n",acu);
    }

}

10  Programación / Programación C/C++ / Re: Sumar día a una fecha en: 4 Febrero 2015, 19:47 pm
Código:
#include <stdlib.h>
#include <stdio.h>

typedef struct
{
    int dia,
        mes,
        año;
} t_fecha;

void IngrDato();
int EsFechaValida(int,int,int);
int CantDiasMes(int,int);
int EsBisiesto(int);
void SumaUnDia(int,int,int);

int main()
{
    system("cls");
    IngrDato();
    printf("\n");
    return 0;
}

void IngrDato()
{
    t_fecha fecha;
    printf("\n Ingrese el dia: ");
    scanf("%d",&fecha.dia);
    printf("\n Ingrese el mes: ");
    scanf("%d",&fecha.mes);
    printf("\n Ingrese un año: ");
    scanf("%d",&fecha.año);

    if (EsFechaValida(fecha.dia,fecha.mes,fecha.año) == 1)
        printf("\n Es valida");
    else
        printf("\n No es valida");
     SumaUnDia(fecha.dia,fecha.mes,fecha.año);
}



int EsFechaValida(int dia,int mes,int año)
{
    int fv = 0;
    if (año > 1600)
        if (mes >= 1 && mes <= 12)
            if (dia >= 1 && dia <= CantDiasMes(mes,año))
                fv = 1;
    return (fv);
}


int CantDiasMes(int mm,int aa)
{
    int cdm;
    cdm = 31;

    if(mm == 4 || mm == 6 || mm == 9 || mm == 11 )
    {
        cdm = 30;
    }
    else
    {
        if (mm == 2)
        {
            cdm = 28+EsBisiesto(aa);
        }
    }
    return(cdm);
}

int EsBisiesto(int a)
{
    int b;
    if ((a%4==0 || a%100==0)||(a%400==0))
        b=1;
    else
        b=0;
    return(b);
}

void SumaUnDia(int d,int m,int a)
{
int df, mf, af;
df = d+1;
mf = m;
af = a;

if (df <= CantDiasMes(mf,af))
{
mf++;
df = 1;
if (mf>12)
{
af++;
mf = 1;
}
}
printf("\n\n Dia: %d  Mes: %d  año:%d", df, mf, af);
}
Páginas: [1] 2
WAP2 - Aviso Legal - Powered by SMF 1.1.21 | SMF © 2006-2008, Simple Machines