Mensajes

Para calcular la MODA puedes usar map<int, int> en lugar de vector<int>... y con una iteración puedes obtener el elemento con mayor cantidad...

edad NO ES UN ARRAY!¡, mejor lee un manual/tutorial/guia al respecto.

Código (cpp,3,20,22,23,24,31,35) [Seleccionar] Expandir


int main(){

int edad,personas,i,j,aux,suma_edad;
int moda,frecuencia,frecuencia_moda;

   cout<<"introduzca el numero de personas"<<endl;
   cin>>personas;

   vector<int>v(personas);
   for(i=0;i<v.size();i++)
   {
       cout<<"introduzca las edades"<<endl;
       cin>>edad;
       v[i]=edad;
   }
//moda

   for(i=0;i<personas-1;i++)
       for(j=0;j<personas-i;j++)
           if(edad[j]>edad[j+1])
           {
               aux=edad[j];
               edad[j]=edad[j+1];
               edad[j+1]=aux;
           }
   frecuencia=0;
   frecuencia_moda=0;
   moda=-1;

   for(i=0;i<personas-1;i++)
       if(edad[i]==edad[i+1])
           if(++frecuencia>frecuencia_moda)
           {
               frecuencia_moda=frecuencia;
               moda=edad[i];
           }
           else
               frecuencia=0;

   system("PAUSE");
   return 0;
}


Código (cpp) [Seleccionar] Expandir


#include <iostream>
#include <map>
using namespace std;

int main(){

   map<uint32_t, uint32_t> cantMap;
   map<uint32_t, uint32_t>::iterator maxEdad;
   uint32_t cantPersonas,
            edad;

   cout << "introduzca el numero de personas" << endl;
   cin >> cantPersonas;

   cout<<"introduzca las edades"<<endl;

   for (uint32_t i = 0;
        i < cantPersonas;
        ++i)
   {
       cout << "Edad Numero: " << i << endl;
       cin >> edad;
       cantMap[edad]++;
   }

   maxEdad = cantMap.begin();

/**
Calcular moda con un For mira este enlace y a ver si se te prende el foco:
http://www.cplusplus.com/reference/map/map/begin/
*/

   cout << maxEdad->first << " => " << maxEdad->second << endl;

   cin.sync();
   cin.get();

   return 0;
}


Dulces Lunas!¡.

Tu forma de programar me parece que es pensando en C mas no en C++ (Orientado a objetos)... como mencionas es mejor comentar el código (PERO SOLO LO NECESARIO no tan exagerado, ve los códigos de la STL), a su vez si estas en un lenguaje ORIENTADO A OBJETOS es mejor programar orientado a Objetos y no "lineal" como C, para entenderlo esta bueno el vídeo.

P.D.: Que raro... incluyes endl del namespace std pero en su lugar usa "\n"... no es malo pero lo ideal es que usaras endl en lugar de "\n"..., por otro lado en C++ es mejor que uses CLASES...

Dulces Lunas!¡.

@zonahurbana
Si te fijas bien el usa ya el proceso sort()... PERO NO DICE ni aclara su problema.

En el sort() usas el proceso ordena_nom() pero no dejas su código... ¿Si te COMPILA este código? yo creo que no.

Dulces Lunas!¡.

Total ya tienes dos opciones define tu vertiente:

SetWindowtext().
SendMessage() con WM_SETTEXT.

Solo mencione una alternativa. Lo del DC creo que me exprese mal quería decir que se auto pintaba pero da igual no es el caso este tema le servira a mas de una persona.

P.D.: Me parece que el caso o problema es en la propia instancia del programa.
P.D.: Se nota que sabes bastante pero no hay necesidad de restregar cada palabra que necesidad de demostrar, me pregunto que diría un psicologo.

Dulces Lunas!¡.

[Te podría "sustituir"]

SendMessage no puede "sustituir" como dices, si se utiliza SendMessage se estara saltando Mensajes de proceso de Windows tales como actualización de tamaño de
objetos de Ventanas, actualización de la region del cliente, mensajes que son usados por aplicaciones ( incluso por otros procesos ). por ejemplo
WM_PAINT para redibujar el area que ha sido cubierta por otra ventana/control de otros proceso. Crees que Microsoft creo tales funciones para nada?  
Así que porque implementar un ShowWindow o MoveWindow y hacer todo el trabajo manualmente?

Además, no hay razon de usar SetWindowText debido a que esta funcion termina usando los mensajes de windows. SendMessage es mejor
debido a que no solo puede cambiar el texto ( en este caso ) de un control del llamador sino también de otra aplicación/proceso.
Aprender muy bien a usar las funciones que ofrece Windows.

SendMessage tiene una infinidad de funciones (Te podría "sustituir" MoveWindow(), ShowWindow() emular clicks, pulsaciones, etc ya que se especia-lisa en mandar mensajes).

SetWindowText para cambiar texto.

Dulces Lunas!¡.

¿¿??

SetWindowText() también requiere el handle (de cualquier ventana accesible). Al final esta API llama a sendmessage() pero no te "enredas" con los mensajes es un poco mas simple.

P.D.: Cuando se manda el mensaje con SendMessage() me PARECE que se tiene que repintar el DC...

Dulces Lunes.

Dos simples códigos de ejemplo:

Use algunos Cast para que se entienda...

Solo numeros o punteros o cualquier cosa no mayor a un sizeof(list_value_t).

Código (c) [Seleccionar] Expandir


#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <inttypes.h>
//#include "include/CSAVL.h"
//#include "include/CSMap.h"
#include "include/CSList.h"
//#include "include/CSQueue.h"
//#include "include/CScript.h"
//#include "include/CSUtiles.h"

uint32_t min(uint32_t a, uint32_t b);
void    swap(int32_t *a, int32_t *b);
int32_t randomnumber(int32_t lower, int32_t upper);
void    test();

int main() {
   list_t list1 = list_allocator(NULL, NULL, NULL);
   struct list_item *item = NULL;

   puts("Prueba de list_t");

   puts("Ingresando datos.");
   for (uint_fast32_t i = 0; i < VALUES_TO_ADD; ++i) {
       list_pushback(list1, randomnumber(0, 100));
   }
   puts("fin de insercion de los datos.\n");

   puts("Liberando memoria de list_t"); list_clear(list1);
   printf("\n\nOK\n");
   getchar();

   return EXIT_SUCCESS;
}

uint32_t min(uint32_t a, uint32_t b) {
   return (a<b) ? a:b;
}

void swap(int32_t *a, int32_t *b) {
   *a ^= *b;
   *b ^= *a;
   *a ^= *b;
}

int32_t randomnumber(int32_t lower, int32_t upper) {
   if (min(lower, upper) != lower) {
       swap(&lower, &upper);
   }
   return lower + rand() % ((upper + 1) - lower);
}


Con estructuras:

Código (c) [Seleccionar] Expandir


struct persona_datos {
   char *nombre;
   char apellido[256];
   unsigned edad;
};
long    min(uint32_t a, uint32_t b);
void    swap(int32_t *a, int32_t *b);
int32_t randomnumber(int32_t lower, int32_t upper);
void    test();


list_value_t
callback_clone_item(const list_value_t value) {
   if (!value) return NULL; /**< No hay nada que clonar */
   struct persona_datos *__ptr = (struct persona_datos *)value; /**< Original */
   struct persona_datos *__new = (struct persona_datos *)malloc(sizeof (struct persona_datos));
   size_t __ln = 0;

   if (__ptr->nombre) { // nombre es un puntero a un array char por ello reservamos memoria.
       if ((__ln = strlen(__ptr->nombre)) > 0) {
           __new->nombre = (char*)malloc((__ln + 1));// * sizeof(char)); // Omitimos.
           strcpy(__new->nombre, __ptr->nombre);
       }
   }
   strcpy(__new->apellido, __ptr->apellido); // apellido e suna rray no un puntero...
   __new->edad = __ptr->edad;

   return (list_value_t)__new; /**< retornamos __new. */
}

void
callback_release_item(const list_value_t value) {
   if (!value) return; /**< No hay nada que liberar */
   struct persona_datos *__ptr = (struct persona_datos *)value; /**< Original esta se creo en el callback callback_clone_item() */
   free(__ptr->nombre);
   free(__ptr);
}

enum list_cmp
callback_compare_item(const list_value_t value1,
                     const list_value_t value2) {
   struct persona_datos *__ptr1 = (struct persona_datos *)value1;
   struct persona_datos *__ptr2 = (struct persona_datos *)value2;
   /**< Comparamos las edades */
   if (__ptr1->edad > __ptr2->edad) {
       return LIST_CMP_GREATER_THAT;
   } else if (__ptr1->edad < __ptr2->edad) {
       return LIST_CMP_LESS_THAT;
   }
   return LIST_CMP_EQUAL;
}

int main() {
   list_t list1 = list_allocator(callback_clone_item,
                                 callback_release_item,
                                 callback_compare_item);
   struct persona_datos dato = {};
   char buff[256] = {}; /**< Buffer usado en miembro nombre. */

   puts("Prueba de list_t");

   puts("Ingresando datos.");
   dato.nombre = buff;
   for (uint_fast32_t i = 0; i < VALUES_TO_ADD; ++i) {
       dato.edad = randomnumber(0, 100);
       sprintf(dato.nombre, "Nombre %"PRIdFAST32, i); /**< dato.nombre apunta a un buffer de 256 caracteres */
       sprintf(dato.apellido, "Apellido %"PRIdFAST32, i);
       list_pushback(list1, (list_value_t)&dato);
   }
   puts("fin de insercion de los datos.\n");

   puts("Liberando memoria de list_t"); list_clear(list1);
   printf("\n\nOK\n");
   getchar();

   return EXIT_SUCCESS;
}


Dulces Lunas!¡.

Son varias funciones para tratar a las listas, Absténganse de entregar a sus maestros este código si no lo llegan a comprender lo "básico". NO INCLUÍ las funciones de ordenamiento debido a que tienen un problema, seguro se me paso alguno... igual no es nada del otro mundo (fue cuando incluí la macro LIST_INTEGRAL_RELATIONSHIP).

list.h

Código (c) [Seleccionar] Expandir


#ifndef LIST_H_INCLUDED
#define LIST_H_INCLUDED

/** \autor Ortega Avila Miguel Angel (BlackZeroX).
*
* \website http://infrnagelux.sytes.net/
* \copileft El presente código se da de manera gratuita sin ningún derecho a venta.
* \note muchas de las funciones aqui presentadas "inútiles" como:
* list_before()
* list_after()
* list_getlist()
* Note que esta ultima solo esta activa mientras este declarada la macro.
*
* http://foro.elhacker.net/programacion_cc/srcc99_para_que_dejen_de_preguntar_por_las_listas-t380839.0.html
*
*/

#include <stdbool.h>
#include <stdlib.h>
#include <stddef.h>
#include <stdint.h>

#ifndef LIST_INTEGRAL_RELATIONSHIP
/** \brief Al declarar LIST_INTEGRAL_RELATIONSHIP se reduce considerablemente la velocidad
* en el proceso list_sort() debido a que se actualizan TODOS los miembros list de la estructura
* struct list_item de cada elemento; De igual manera aumenta la seguridad de no eliminar o hacer
* operaciones indebidas entre elementos.
*
*/
///#define LIST_INTEGRAL_RELATIONSHIP /**< Comentar/descomentar */
#endif

#define LIST_SIZE_ITEM sizeof(struct list_item)

struct list;
typedef void*               list_value_t; ///typedef uintptr_t            list_value_t;
typedef struct list*        list_t;

/** \brief Definición callback que se encarga de crear un duplicado de un elemento de lista.
* \param item: Valor a duplicar.
*
* \return Retorna el elemento list_value_t duplicado del parámetro value.
*
*/
typedef list_value_t (*list_callback_clone_item)
(const list_value_t value);

/** \brief Definición de callback que se encarga de destruir la memoria asignada al list_value_t.
*
* \param item: Puntero a la estructura que se le pretende liberar su valor asignado debe liberarse solo el miembro value.
*
*/
typedef
void(*list_callback_release_item)
(const list_value_t value);

/** \brief Definición de callback que se encarga comparar dos list_value_t.
*
* \param value1: list_value_t que se comparara con value2.
* \param value2: list_value_t que se comparara con value1.
* \return Retorna el resultado de la comparación.
* LIST_CMP_LESS_THAT: Si value1 < value2.
* LIST_CMP_EQUAL: Si value1 == value2.
* LIST_CMP_GREATER_THAT: Si value1 > value2.
*
*/
typedef
enum list_cmp(*list_callback_compare_item)
(const list_value_t value1,
const list_value_t value2);

enum list_cmp {
   LIST_CMP_EQUAL          = 1,    /**< */
   LIST_CMP_LESS_THAT      = 2,    /**< */
   LIST_CMP_GREATER_THAT   = 4     /**< */
};

enum list_sort {
   LIST_SORT_ASC,  /**< */
   LIST_SORT_DESC  /**< */
};

struct list_item {
   list_value_t        value;  /**< Valor del item actual. */
   struct list_item    *prev;  /**< Apuntador al item derecho. */
   struct list_item    *next;  /**< Apuntador al item izquierdo. */
   #ifdef LIST_INTEGRAL_RELATIONSHIP
   list_t              list;   /**< Apuntador a los datos generales de la lista. */
   #endif
};


struct list {                       /**< Estructura que guarda la información generalizada de una lista de datos */
   struct list_item    *first;     /**< Primer elemento agregado a la lista */
   struct list_item    *last;      /**< Ultimo elemento agregado a la lista */
   #ifdef LIST_INTEGRAL_RELATIONSHIP
   size_t              size;       /**< Cantidad de elementos */
   #endif
   list_callback_clone_item    clone_item;     /**< Puntero a la función callback que realiza las acciones CLONE, RELEASE y COMPARE */
   list_callback_release_item  release_item;   /**< Puntero a la función callback que realiza las acciones CLONE, RELEASE y COMPARE */
   list_callback_compare_item  compare_item;   /**< Puntero a la función callback que realiza las acciones CLONE, RELEASE y COMPARE */
};

/** \brief Obtiene el item siguiente al inicado.
*
* \param item: Item pivote en la lista.
* \return Retorna el struct list_item * siguiente al indicado; NULL si no hay ningun item.
*
*/
struct list_item*
list_after(struct list_item *item);

/** \brief Crea una nueva lista de elementos list_value_t.
*
* \param clone_item: Apuntador a la función callback que retornara la copia del valor a asignar.
* \param release_item: Apuntador a la función callback que liberara la copia del valor duplicado en el list_callback_clone_item.
* \param clone_item: Apuntador a un proceso callback que se encarga de comparar los struct list_item *.
* \return Retorna la nueva cola de datos queue_t que deberá ser destruida con list_release().
*
*/
list_t
list_allocator(list_callback_clone_item clone_item,
              list_callback_release_item release_item,
              list_callback_compare_item compare_item);

/** \brief Agrega n cantidad de elementos repetidos (value) a la lista, reemplazando los existentes.
*
* \param list: Lista en la que se agregara value n veces.
* \param n: Cantidad de valores a agregar a la lista.
* \param value: Valor a agregar n veces a la lista.
* \return Retorna el primer elemento agregado; NULL si no se a agregado ningun elemento.
*
*/
struct list_item*
list_assign(list_t list,
           size_t n,
           list_value_t value);

/** \brief Obtiene el ultimo elemento de una lista.
*
* \param list: Lista de la cual se obtendrá el ultimo elemento struct list_item *.
* \return Devuelve el ultimo struct list_item * de la lista.
*
*/
struct list_item*
list_back(list_t list);

/** \brief Obtiene el item anterior al inicado.
*
* \param item: Item pivote en la lista.
* \return Retorna el struct list_item * anterior al indicado; NULL si no hay ningun item.
*
*/
struct list_item*
list_before(struct list_item *item);

/** \brief Obtiene el primer elemento de una lista.
*
* \param list: Lista de la cual se obtendrá su primer elemento struct list_item *.
* \return Devuelve el primer struct list_item * de la lista.
*
*/
struct list_item*
list_begin(list_t list);

/** \brief Remueve/Libera TODOS los elementos de la lista.
*
* \param list: Puntero a la struct list que se limpiara.
* \return Retorna la cantidad de elementos removidos de la lista.
*
*/
size_t
list_clear(list_t list);

/** \brief Función que clona por completo una lista.
*
* \param list: Lista que será clonada.
* \return Retorna una nueva lista que deberá ser liberada con list_release().
*
*/
list_t
list_clone(list_t list);

/** \brief Copia los elementos de una lista a otra.
*
* \param list: Lista a la que pertenece el item pasado por el parámetro dst.
* \param dst: Elemento pivote en donde se se ubicaran los elementos a copiar desde src.
* \param src: Elemento pivote de una lista que se le clonaran sus elementos para agregarlos en la lista destino dst.
* \param n: Cantidad máxima de elementos que copiaran.
* \return Retorna la cantidad de elementos agregados en la lista dst.
*
*/
size_t
list_copy(list_t list,
         struct list_item *dst,
         struct list_item *src,
         size_t n);

/** \brief Verifica si una lista esta vacia.
*
* \param list: Lista que se verificara.
* \return Retorna:
*  true: si la lista esta vacia.
*  false: Si contiene por lo menos un elemento.
*
*/
bool
list_empty(list_t list);


/** \brief Elimina un struct list_item * de su lista.
*
* \param list: Lista a la que pertenece el item.
* \param item: Elemento que se eliminara/liberara de su lista.
*
*/
void
list_erase(list_t list,
          struct list_item *item);

/** \brief Libera la memoria un struct list_item * NO RELACIONADA con una lista (miembro list debe ser igual a NULL).
*
* \param item: Elemento que se eliminara/liberara de su lista.
* \param callback_release_value: Callback a la función que esta encargada de liberar la memoria del miembro value.
*
*/
void
list_release_item(struct list_item *item,
                 list_callback_release_item callback_release_value);

/** \brief Remueve la relación que tiene el elemento con su lista madre (Usar con cuidado).
*
* \param list: Lista a la que se le extraerá el elemento.
* \param item: Elemento que se extraerá de su lista.
* \return Retorno el valor pasado en el parámetro item si se extrajo correctamente, de lo contrario retorna NULL.
*
*
* \code
* void
* list_release_item(struct list_item *item,
*                   list_callback_release_item callback_release_value) {
*     if (!item)
*         return;
*
*     if (callback_release_value)
*         callback_release_value(item->value);
* #ifdef LIST_INTEGRAL_RELATIONSHIP
*     free(list_extract(NULL, item));
* #else
*     free(list_extract(NULL, item));
* #endif
* }
* \endcode
*
*/
struct list_item*
list_extract(list_t list, struct list_item *item);

/** \brief Busca un valor a partir de un pivote indicado dentro de una lista.
*
* \param list: Lista a la que pertenecen los elementos (incluye parámetro item).
* \param item: Elemento pivote desde el cual se empezara a buscar el valor indicado en value.
* si es NULL iniciara desde el inicio de la lista.
* \param value: Valor a buscar en la lista a partir de el pivote indicado.
* \return Retorna NULL si no se a encontrado dentro de la lista en caso
* contrario retorna el elemento .
*
*/
struct list_item*
list_findnext(list_t list,
             struct list_item *item,
             list_value_t value);


/** \brief Busca un valor a partir de un pivote indicado dentro de una lista.
*
* \param list: Lista a la que pertenecen los elementos.
* \param item: Elemento pivote desde el cual se empezara a buscar el valor indicado en value,
* si es NULL iniciara a buscar desde el final de la lista.
* \param value: Valor a buscar en la lista antes de el pivote indicado.
* \return Retorna NULL si no se a encontrado dentro de la lista en caso
* contrario retorna el puntero al item.
*/
struct list_item*
list_findprev(list_t list,
             struct list_item *item,
             list_value_t value);

#ifdef LIST_INTEGRAL_RELATIONSHIP
/** \brief Obtiene la lista a la cual pertenece un item.
*
* \param item: elemento a consultar.
* \return Devuelve la lista a la cual pertenece dicho item; NULL si no pertenece a ninguna lista.
*
*/
list_t
list_getlist(struct list_item *item);
#endif

/** \brief Mezcla dos listas generando una nueva lista que deberá ser liberada con list_release().
*
* \param list1: Los elementos de esta lista se agregaran al inicio.
* \param list2: Los elementos de esta lista se agregaran al seguidos de los de list1.
* \return Retorna una nueva lista que  contendrán  las copias de las dos listas espesificadas.
*
*/
list_t
list_join(list_t list1,
         list_t list2);

/** \brief Agrega un valor al final de la lista.
*
* \param list: lista a la cual se le agregara un elemento nuevo.
* \param value: Valor a agregar a la lista.
* \return Retorna el puntero al item en la lista, NULL si fallo.
*
*/
struct list_item*
list_pushback(list_t list,
             list_value_t value);

/** \brief Agrega un elemento struct list_item al final de la lista (No crea un duplicado del elemento).
*
* \param list: lista a la cual se le agregara un elemento nuevo.
* \param item: Puntero al elemento struct list_item a relacionar con la lista.
* \return Retorna el puntero al item en la lista (el retorno es igual a el parámetro item), NULL si fallo.
*
*/
struct list_item*
list_pushback_item (list_t list,
                   struct list_item *item);

/** \brief Agrega un valor al inicio de la lista.
*
* \param list: Lista a la cual se le agregara un elemento nuevo.
* \param value: Valor a agregar a la lista.
* \return Retorna el puntero al item en la lista.
*
*/
struct list_item*
list_pushfront(list_t list,
              list_value_t value);

/** \brief Agrega un elemento struct list_item al inicio de la lista (No crea un duplicado del elemento).
*
* \param list: lista a la cual se le agregara un elemento nuevo.
* \param item: Puntero al elemento struct list_item a relacionar con la lista.
* \return Retorna el puntero al item en la lista (el retorno es igual a el parámetro item), NULL si fallo.
*
*/
struct list_item*
list_pushfront_item (list_t list,
                    struct list_item *item);

/** \brief Agrega un valor en la lista después de un elemento indicado como pivote.
*
* \param list: lista en la que se agregara.
* \param pivot: Elemento pivote que esta dentro de una lista, si el valor es NULL value se agregara al final de la lista.
* \param value: Valor a agregar a la lista después del pivote.
* \return Retorna el puntero al item en la lista, NULL si fallo.
*
*/
struct list_item*
list_pushnext(list_t list,
             struct list_item *pivot,
             list_value_t value);

/** \brief Agrega un elemento struct list_item después de un elemento indicado como pivote (No crea un duplicado del elemento).
*
* \param list: lista en la que se agregara.
* \param pivot: Elemento pivote que esta dentro de una lista, si el valor es NULL itemnew se agregara al final de la lista.
* \param itemnew: Puntero al elemento struct list_item a relacionar con la lista.
* \return Retorna el puntero al item en la lista (el retorno es igual a el parámetro itemnew), NULL si fallo.
*
*/
struct list_item*
list_pushnext_item(list_t list,
                  struct list_item *pivot,
                  struct list_item *itemnew);


/** \brief Agrega un elemento en la lista antes de un elemento indicado.
*
* \param list: lista en la que se agregara.
* \param pivot: Elemento pivote que esta dentro de una lista, si el valor es NULL value se agregara al final de la lista.
* \param value: Valor a agregar a la lista antes del pivote.
* \return Retorna el puntero al item en la lista, NULL si fallo.
*
*/
struct list_item*
list_pushprev(list_t list,
             struct list_item *pivot,
             list_value_t value);

/** \brief Agrega un elemento struct list_item antes de un elemento indicado como pivote (No crea un duplicado del elemento).
*
* \param list: lista en la que se agregara.
* \param pivot: Elemento pivote que esta dentro de una lista, si el valor es NULL itemnew se agregara al final de la lista.
* \param itemnew: Puntero al elemento struct list_item a relacionar con la lista.
* \return Retorna el puntero al item en la lista (el retorno es igual a el parámetro itemnew), NULL si fallo.
*
*/
struct list_item*
list_pushprev_item(list_t list,
                  struct list_item *pivot,
                  struct list_item *itemnew);

/** \brief Destruye una lista, los elementos también son liberados.
*
* \param list: Puntero a la struct list a destruir.
*/
void
list_release(list_t list);

/** \brief Obtiene la cantidad de elementos en la lista.
*
* \param list: Lista de la cual se retornaran la cantidad de elementos almacenados en ella.
* \return Retorna la cantidad de elementos en la lista.
*
*/
size_t
list_size(list_t list);

/** \brief Intercambia los elementos de cada lista.
*
* \param list1: Lista involucrada que se cambiaran los elementos con list2.
* \param list2: Lista involucrada que se cambiaran los elementos con list1.
* \return Retorna TRUE si no hubo errores y FALSE si no se puedo intercambiar los elementos.
*
*/
void
list_swap(list_t list1,
         list_t list2);

#endif // LIST_H_INCLUDED



list.c

Código (c) [Seleccionar] Expandir


#include "include/List.h"

/** \brief callback predeterminado que se encarga de crear un duplicado del queue_value_t para el stack_item_t.
 *
 * \param value: queue_value_t que se asignara.
 * \return Debe retornarse el queue_value_t a asignar al stack_item_t que se esta creando.
 *
 */
list_value_t
list_callback_clone_item_default(const list_value_t value) {
   return value;
}


/** \brief callback predeterminado que se encarga de destruir la memoria asignada al stack_item_t.
 *
 * \param value: queue_value_t que se liberara.
 *
 */
void
list_callback_release_item_default(const list_value_t value) {
   /// none code
}


/** \brief callback predeterminado que se encarga comparar dos list_value_t.
 *
 * \param value1: se comparara con value2.
 * \param value2: se comparara con value1.
 * \return Retorna el resultado de la comparación.
 * LIST_CMP_LESS_THAT: Si value1 < value2.
 * LIST_CMP_EQUAL: Si value1 == value2.
 * LIST_CMP_GREATER_THAT: Si value1 > value2.
 *
 */
enum list_cmp
list_callback_compare_item_default(const list_value_t value1,
                                  const list_value_t value2) {
   if (value1 > value2) {
       return LIST_CMP_GREATER_THAT;
   } else if (value1 < value2) {
       return LIST_CMP_LESS_THAT;
   }
   return LIST_CMP_EQUAL;
}

struct list_item*
list_after(struct list_item *item) {
   return item ? item->next : NULL;
}

list_t
list_allocator(list_callback_clone_item       clone_item,
              list_callback_release_item     release_item,
              list_callback_compare_item     compare_item) {
   list_t list = malloc(sizeof (struct list));
   list->first = list->last = NULL;
#ifdef LIST_INTEGRAL_RELATIONSHIP
   list->size = 0;
#endif //LIST_INTEGRAL_RELATIONSHIP
   list->clone_item = clone_item ? clone_item : list_callback_clone_item_default;
   list->release_item = release_item ? release_item : list_callback_release_item_default;
   list->compare_item = compare_item ? compare_item : list_callback_compare_item_default;
   return list;
}

void
list_allocator_array(list_t *array,
                    size_t n,
                    list_callback_clone_item       clone_item,
                    list_callback_release_item     release_item,
                    list_callback_compare_item     compare_item) {
   for (register size_t i = 0; i < n; ++i)
       array[i] = list_allocator(clone_item, release_item, compare_item);
}

struct list_item*
list_assign(list_t list,
           size_t n,
           list_value_t value) {
   struct list_item *ret = NULL;

   if (!list)
       return NULL;

   list_clear(list);
   ret = (n > 0) ? list_pushback(list, value) : NULL;

   for (register size_t i = 1; i < n; i++)
       list_pushback(list, value);

   return ret;
}

struct list_item*
list_back(list_t list) {
   return list ? list->last : NULL;
}

struct list_item*
list_before(struct list_item *item) {
   return item ? item->prev : NULL;
}

struct list_item*
list_begin(list_t list) {
   return list ? list->first : NULL;
}

size_t
list_clear(list_t list) {
   struct list_item *item = NULL;
   size_t     ret = 0;
   while((item = list->first) != NULL) {
       list_erase(list, item);
       ++ret;
   }
   return ret;
}

list_t
list_clone(list_t list) {
   list_t ret = NULL;
   struct list_item *item = NULL;

   if (!list)
       return NULL;

   ret = list_allocator(list->clone_item, list->release_item, list->compare_item);

   for (item = list_begin(list); item != NULL; item = list_after(item))
       list_pushback(ret, item->value);

   return ret;
}

size_t
list_copy(list_t list,
         struct list_item *dst,
         struct list_item *src,
         size_t n) {
   size_t ret = 0;

   if (!(dst && src)) return 0;
#ifdef LIST_INTEGRAL_RELATIONSHIP
   if (!(dst->list && dst->list == list)) return 0;
#endif //LIST_INTEGRAL_RELATIONSHIP

   while (n > 0 && src != NULL) {
       list_pushback(list, src->value);
       src = src->next;
       --n; ++ret;
   }

   return ret;
}

bool
list_empty(list_t list) {
   return  list && list->first && list->last ? true : false;
}

void
list_erase(list_t list,
          struct list_item *item) {
   if (!(item && list)) return;
#ifdef LIST_INTEGRAL_RELATIONSHIP
   else if (item->list != list) return;
#endif //LIST_INTEGRAL_RELATIONSHIP
   if (list && list->release_item)
       list->release_item(item->value);

   free(list_extract(list, item));
}

void
list_release_item(struct list_item *item,
                 list_callback_release_item callback_release_value) {
   if (!item)
       return;

   if (callback_release_value)
       callback_release_value(item->value);
#ifdef LIST_INTEGRAL_RELATIONSHIP
   free(list_extract(NULL, item));
#else
   free(list_extract(NULL, item));
#endif // LIST_INTEGRAL_RELATIONSHIP
}

struct list_item*
list_extract(list_t list,
            struct list_item *item) {
   if (!item) return NULL;
#ifdef LIST_INTEGRAL_RELATIONSHIP
   else if (item->list != list) return NULL;
#endif // LIST_INTEGRAL_RELATIONSHIP

   if (list) {
       if (list->first == item) list->first = item->next;
       if (list->last == item) list->last = item->prev;

   } else if (item->prev || item->next) {
       return NULL;
   }
   if (item->prev) item->prev->next = item->next;
   if (item->next) item->next->prev = item->prev;
   item->prev = NULL;
   item->next = NULL;
#ifdef LIST_INTEGRAL_RELATIONSHIP
   --(list->size);
   item->list = NULL;
#endif // LIST_INTEGRAL_RELATIONSHIP
   return item;
}

struct list_item*
list_findnext(list_t list,
             struct list_item *item,
             list_value_t value) {

   if (!list) return NULL;
   else if (!list->compare_item) return NULL;
   if (!item) item = list->first;
#ifdef LIST_INTEGRAL_RELATIONSHIP
   else if (item->list != list) return NULL;
#endif // LIST_INTEGRAL_RELATIONSHIP

   struct list_item   *now = item;

   do {
       if ((list->compare_item)(now->value, value) & LIST_CMP_EQUAL)
           return now;
       now = now->next;
   } while (now);

   return NULL;
}

struct list_item*
list_findprev(list_t list,
             struct list_item *item,
             list_value_t value) {
   if (!list) return NULL;
   else if (!list->compare_item) return NULL;
   if (!item) item = list->last;
#ifdef LIST_INTEGRAL_RELATIONSHIP
   else if (item->list != list) return NULL;
#endif // LIST_INTEGRAL_RELATIONSHIP

   struct list_item   *now = item;

   do {
       if ((list->compare_item)(now->value, value) & LIST_CMP_EQUAL)
           return now;
       now = now->prev;
   } while (now);

   return NULL;
}

#ifdef LIST_INTEGRAL_RELATIONSHIP
list_t
list_getlist(struct list_item *item) {
   if (!item) return NULL;
   return item->list;
}
#endif // LIST_INTEGRAL_RELATIONSHIP

list_t
list_join(list_t list1,
         list_t list2) {
   list_t              list = list_clone(list1);
   struct list_item    *item = NULL;

   for (item = list_begin(list2); item != NULL; item = list_after(item))
       list_pushback(list, item->value);
   return list;
}

struct list_item*
list_pushback(list_t list,
             list_value_t value) {
   struct list_item   *itemnew = NULL;

   if (list && !list->clone_item)
       return NULL;

   itemnew = malloc(LIST_SIZE_ITEM);
#ifdef LIST_INTEGRAL_RELATIONSHIP
   itemnew->list = NULL;
#endif

   if (list_pushback_item(list, itemnew) != itemnew) {
       free(itemnew);
       return NULL;
   }

   itemnew->value = (list->clone_item)(value);

   return list->last;
}

struct list_item*
list_pushback_item (list_t list,
                   struct list_item *item) {
#ifdef LIST_INTEGRAL_RELATIONSHIP
   if (!(list && item && !item->list))
       return NULL;
#else
   if (!(list && item))
       return NULL;
#endif // LIST_INTEGRAL_RELATIONSHIP

   if (!(list->first && list->last)) {
       list->first = item;
       item->prev = NULL;
   } else {
       list->last->next = item;
       item->prev = list->last;
   }

   item->next = NULL;
#ifdef LIST_INTEGRAL_RELATIONSHIP
   ++(list->size);
   item->list = list;
#endif // LIST_INTEGRAL_RELATIONSHIP
   list->last = item;

   return item;
}

struct list_item*
list_pushfront(list_t list,
              list_value_t value) {
   struct list_item   *itemnew = NULL;

   if (list || !list->clone_item)
       return NULL;

   itemnew = malloc(LIST_SIZE_ITEM);
#ifdef LIST_INTEGRAL_RELATIONSHIP
   itemnew->list = NULL;
#endif // LIST_INTEGRAL_RELATIONSHIP

   if (list_pushfront_item(list, itemnew) != itemnew) {
       free(itemnew);
       return NULL;
   }
   itemnew->value = (list->clone_item)(value);

   return list->first;
}

struct list_item*
list_pushfront_item(list_t list,
                   struct list_item *item) {
#ifdef LIST_INTEGRAL_RELATIONSHIP
   if (!(list && item && !item->list))
       return NULL;
#else
   if (!(list && item))
       return NULL;
#endif // LIST_INTEGRAL_RELATIONSHIP

   if (!(list->first && list->last)) {
       list->last = item;
       item->next = NULL;
   } else {
       list->first->prev = item;
       item->next = list->first;
   }

   item->prev = NULL;

#ifdef LIST_INTEGRAL_RELATIONSHIP
   ++(list->size);
   item->list = list;
#endif // LIST_INTEGRAL_RELATIONSHIP

   list->first = item;

   return item;
}

struct list_item*
list_pushnext(list_t list,
             struct list_item *pivot,
             list_value_t value) {
   if (!list) return NULL;
   if (!pivot) pivot = list->last;
#ifdef LIST_INTEGRAL_RELATIONSHIP
   else if (pivot->list != list) return NULL;
#endif // LIST_INTEGRAL_RELATIONSHIP

   struct list_item *itemnew = malloc(LIST_SIZE_ITEM);

   if (list_pushnext_item(list, pivot, itemnew) != itemnew) {
       free(itemnew);
       return NULL;
   }

   itemnew->value = (list->clone_item)(value);

   return itemnew;
}

struct list_item*
list_pushnext_item(list_t list,
                  struct list_item *pivot,
                  struct list_item *itemnew) {

   if (!(list && itemnew)) return NULL;
   if (!pivot) pivot = list->last;
#ifdef LIST_INTEGRAL_RELATIONSHIP
   else if (pivot->list != list) return NULL;
#endif // LIST_INTEGRAL_RELATIONSHIP

   if (pivot) {
       if (!pivot->next)
           return list_pushback_item(list, itemnew);
       pivot->next->prev = itemnew;
       itemnew->next = pivot->next;
       pivot->next = itemnew;
       itemnew->prev = pivot;
#ifdef LIST_INTEGRAL_RELATIONSHIP
       ++(itemnew->list->size);
       itemnew->list = pivot->list;
#endif // LIST_INTEGRAL_RELATIONSHIP
       return itemnew;
   } else {
       return list_pushback_item(list, itemnew);
   }

   return NULL;
}

struct list_item*
list_pushprev(list_t list,
             struct list_item *pivot,
             list_value_t value) {

   if (!list) return NULL;
   if (!pivot) pivot = list->first;
#ifdef LIST_INTEGRAL_RELATIONSHIP
   else if (pivot->list != list) return NULL;
#endif // LIST_INTEGRAL_RELATIONSHIP

   struct list_item *itemnew = malloc(LIST_SIZE_ITEM);

   if (list_pushprev_item(list, pivot, itemnew) != itemnew) {
       free(itemnew);
       return NULL;
   }

   itemnew->value = (list->clone_item)(value);

   return itemnew;
}

struct list_item*
list_pushprev_item(list_t list,
                  struct list_item *pivot,
                  struct list_item *itemnew) {

   if (!(list && itemnew)) return NULL;
   if (!pivot) pivot = list->first;
#ifdef LIST_INTEGRAL_RELATIONSHIP
   else if (pivot->list != list) return NULL;
#endif // LIST_INTEGRAL_RELATIONSHIP

   if (pivot) {
       if (!pivot->prev)
           return list_pushfront_item(list,itemnew);
       pivot->prev->next = itemnew;
       itemnew->prev = pivot->prev;
       pivot->prev = itemnew;
       itemnew->next = pivot;
#ifdef LIST_INTEGRAL_RELATIONSHIP
       itemnew->list = pivot->list;
       ++(itemnew->list->size);
#endif // LIST_INTEGRAL_RELATIONSHIP
       return itemnew;
   } else {
       return list_pushfront_item(list,itemnew);
   }

   return NULL;
}

void
list_release(list_t list) {
   list_clear(list);
   free(list);
}

void
list_release_array(list_t *array,
                  size_t n) {
   for (register size_t i = 0; i < n; ++i)
       list_release(array[i]);
}

size_t
list_size(list_t list) {
#ifdef LIST_INTEGRAL_RELATIONSHIP
   return list ? list->size : 0;
#else
   size_t ret = 0;
   struct list_item *item = list ? list->first : NULL;
   while (item) {
       ++ret;
       item = item->next;
   }
   return ret;
#endif // LIST_INTEGRAL_RELATIONSHIP
}

void
list_swap(list_t list1,
         list_t list2) {
   if (!(list1 && list2)) return;
   struct list tmp = *list2;
   *list2 = *list1;
   *list1 = tmp;
#ifdef LIST_INTEGRAL_RELATIONSHIP
   for (struct list_item *item = list_begin(list1); item != NULL; item = list_after(item))
       item->list = list1;
   for (struct list_item *item = list_begin(list2); item != NULL; item = list_after(item))
       item->list = list2;
#endif // LIST_INTEGRAL_RELATIONSHIP
}


Dulces Lunas!¡.

SendMessage tiene una infinidad de funciones (Te podría "sustituir" MoveWindow(), ShowWindow() emular clicks, pulsaciones, etc ya que se especia-lisa en mandar mensajes).

SetWindowText para cambiar texto.

Dulces Lunas!¡.

* Instale Code::Blocks seguir todas las configuraciones debidas pero me salian muchos errores al compilar asi que me rendí..

Entonces aprende a DEPURAR y evita el copy & paste.

Dulces Lunas!¡.

Se saca el checksum mas adelante de dos estructuras CONSECUTIVAS csum().

Dulces Lunas!¡.