|
41
|
Programación / Programación C/C++ / Re: alguna forma de pasar una funcion miembro como argumento a otro miembro de clase?
|
en: 3 Abril 2022, 01:47 am
|
A voz de pronto se me ocurre que alpha tuviera un flag que pueda activar beta (esto para evitar una recursión infinita). Si ese flag se activa a continuará con su ejecución, sino se repetirá desde el principio. No se C++, pero en C sería algo así: #include <stdio.h> #include <stdbool.h> bool beta() { static int i=0; i++; return i<5; } void alpha() { void alpha() { do { } while(beta()); } } int main() { alpha(); }
Si no quieres usar el do/while puedes usar el goto (si no le tienes manía) #include <stdio.h> #include <stdbool.h> bool beta() { static int i=0; i++; return i<5; } void alpha() { inicio: if(beta()) goto inicio; } int main() { alpha(); }
O mediante setjmp/longjmp (no recomendado) #include <stdio.h> #include <setjmp.h> jmp_buf buf; void beta() { static int i=0; i++; } void alpha() { beta(); } } int main() { alpha(); }
|
|
|
42
|
Programación / Programación C/C++ / Re: Ordenar lista doblemente enlazada con insertion sort
|
en: 27 Marzo 2022, 20:26 pm
|
Sí, es un quebradero de cabeza. Mucho más sencillo cuando se usa un array. Una solución que he conseguido es la siguiente. En C. Esas cosas modernas de C++ se me escapan #include <stdio.h> #include <stdlib.h> #include <stdbool.h> typedef struct node { int data; struct node* prev; struct node* next; } node; void print(node *list) { node *pointer = list; while(pointer) { pointer = pointer->next; } } void insertion_sort(node **head) { // evito una lista vacía if(!*head) { return; } // se recorre la lista de izquierda a derecha for(node *pointer=(*head)->next; pointer; pointer=pointer->next) { // nodo auxiliar para recorrer la lista al revés en busca de datos menores node *aux = pointer; // flag para mantener pointer en su sitio bool flag = true; // ordenando de forma ascendente while(aux->prev && aux->data < aux->prev->data) { // se inicia el intercambio de nodos, el actual por el anterior a este ---------------- // se empieza por hacer que los nodos en los extremos de la pareja actual apunten // a la pareja actual de forma intercambiada. Por ejemplo: sean los cuatro nodos // A B [C] D // C es el nodo actual a comparar // A->next apunta a B // D->prev apunta a C // en el intercambio // A->next debe apuntar a C // D->prev debe apuntar a B // para que esto sea así se debe comprobar que A y D existan para poder operar // contiene la dirección del nodo previo al previo del actual: siendo el actual C, A node *app = aux->prev->prev; // si dicho nodo existe, el siguiente a este deberá ser el actual. A->next apunta a C. if(app) { aux->prev->prev->next = aux; } // si existe un nodo que sea siguiente al actual, su previo debe apuntar al nodo anterior al actual. D->prev apunta a B. if(aux->next) { aux->next->prev = aux->prev; } // intercambio entre la pareja de nodos. // B->prev apunta a C aux->prev->prev = aux; // B->next apunta a D aux->prev->next = aux->next; // C->next apunta a B aux->next = aux->prev; // C->prev apunta a A aux->prev = app; // el primer intercambio se hará lo más a la derecha de la sublista // por lo tanto cuándo se efectua el primer intercambio se debe actualizar // pointer para que apunte al nodo intercambiado. El flag va a evitar que // si se va hacia la izquierda pointer también vaya a la izquierda. if(flag) { pointer = aux->next; flag = false; } // la cabeza de la lista se debe actualizar si hay algún nodo que ha caído en // esa posición if(!aux->prev) *head = aux; } } } bool add(node **head, int data) { node *new = malloc(sizeof(node )); if(!new) { return false; } new->data = data; new->next = NULL; if(*head) { node *pointer = *head; while(pointer->next) { pointer = pointer->next; } pointer->next = new; new->prev = pointer; } else { new->prev = NULL; *head = new; } return true; } void drop(node **head) { node *aux; if(!*head) { return; } while(*head) { aux = *head; *head = (*head)->next; } } int main() { node *list = NULL; add(&list, 5); add(&list, 2); add(&list, 4); add(&list, 1); add(&list, 3); add(&list, 0); print(list); insertion_sort(&list); print(list); drop(&list); }
|
|
|
43
|
Programación / Programación C/C++ / Re: ¿Como controlar punteros a estructuras y meterlo en una funcion?
|
en: 26 Marzo 2022, 11:03 am
|
Sé que C++ tiene otra forma de hacer las cosas, con referencias y tal. No sé. Pero en C sería algo así: #include <stdio.h> #include <stdlib.h> typedef struct node { int data; struct node* prev; struct node* next; } node; node* add(node **head, int data) { node *new = malloc(sizeof(node )); if(!new) { return NULL; } new->data = data; if(*head) { new->prev = (*head)->prev; new->next = *head; (*head)->prev->next = new; (*head)->prev = new; } else { new->next = new; new->prev = new; *head = new; } return new; } void drop(node **head) { node *aux; if(!*head) { return; } (*head)->prev->next = NULL; while(*head) { aux = *head; *head = (*head)->next; } } int main() { node *list = NULL; add(&list, 0); add(&list, 1); add(&list, 2); printf("%d ", list ->next ->data ); printf("%d ", list ->prev ->data ); drop(&list); }
|
|
|
48
|
Programación / Programación C/C++ / Re: Duda sobre nodos y uso de memoria
|
en: 10 Marzo 2022, 18:53 pm
|
Esta línea te sobra nodo *actual=new nodo(); porque le estás pidiendo al sistema memoria para un nodo que no usas. A la siguiente línea le cambias la referencia con actual=lista; y ya has perdido ese 'new nodo()'. Igual en 'eliminarnodo' debes hacer un delete, no basta con cambiar de referencia la pila.
|
|
|
50
|
Programación / Programación C/C++ / Re: Me cago en C/C++
|
en: 5 Marzo 2022, 21:29 pm
|
Va MAFUS no te molestes tanto, si en el titutlo los puse juntos, pero claramente hablo de ellos de forma separada.
No lo digo por ti, sino por el mundo entero, jejeje.
|
|
|
|
|
|
|