"este" puntero en C (no en C++)

Question

Estoy intentando crear una pila en C por diversión, y se me ocurrió la idea de usar struct para representar la pila. Luego agrego punteros a la estructura para las operaciones push() y pop().

Hasta ahora todo parece bueno, pero, para la implementación de las funciones push() y pop(), necesito referirme a * esto de alguna manera. ¿Cómo puede eso (¿puede?) Hacerse?

Esta es mi estructura

struct Stack { 
    int *data; 
    int current_size; 
    int max_size; 
    int (*push)(int); 
    int (*pop)(); 
}; 

Y como ejemplo aquí es empujar

int push(int val) { 
    if(current_size == max_size -1) 
      return 0; 

    data[current_size] = val; 
    current_size++; 

    return 1; 
} 

Como se puede imaginar, el compilador no tiene idea de lo que current_size es decir, como sería de esperar algo así como stack->current_size.

¿Es posible superar esto de alguna manera?

Answer 1

no hay implícita this en C. hacerlo explícito:

int push(Stack* self, int val) { 
    if(self->current_size == self->max_size - 1) 
      return 0; 

    self->data[self->current_size] = val; 
    (self->current_size)++; 

    return 1; 
} 

Usted, por supuesto, tiene que pasar el puntero a la estructura en cada llamada a push y métodos similares.

Esto es esencialmente lo que hace el compilador de C++ cuando define Stack como una clase y push y otros como métodos.

Answer 2

C no funciona así. No es un lenguaje orientado a objetos. Las funciones que manipulan las estructuras de datos deben tomar un puntero a la estructura como argumento.

Answer 3

Los punteros de función no son métodos, por lo que no tienen información sobre el objeto que realiza la llamada. La única forma de hacer lo que desea es pasar un puntero al objeto o hacer que ese puntero sea global (no se recomienda este último).

Answer 4

Obviamente, puede tener un miembro de pila * en la estructura y luego simplemente inicializarlo con la dirección de la estructura antes de utilizar los punteros de función. Luego, haga que Stack * sea un parámetro en los punteros de función.

Answer 5

El enfoque típico en C es que las funciones esperen this como primer parámetro.

int push(Stack *self, int val) 
{ 
    if (self->current_size == self->max_size -1) return 0; 
    self->data[self->current_size++] = val; 
    return 1; 
} 

Esto tiene la ventaja añadida de que, a menos que necesite polimorfismo, no es necesario poner las funciones de la pila, ya que sólo podría llamar push(stack, 10) en lugar de stack->push(stack,10).

Answer 6

Debido a que su van a tener un solo Pila estructura (que denominó pila, al parecer), se podría definir como una variable global. Esto permitiría que pop/push haga referencia directamente a la variable stack.

Se podría hacer algo como:

pila.current_size + = 4;

o utilizar el - operador> si decide declarar pila como un puntero de memoria a Pila.

Answer 7

#include <stdio.h> 
#include <stdlib.h> 
#include <malloc.h> 


typedef struct _foo 
{ 
    int q; 
    void (*Bar)(); 
} Foo; 
Foo * This; 

Foo * foo(Foo * f) 
{ 
    This = f; 
    return f; 
} 

void Bar() 
{ 
    printf("%i\n",This->q); 
    This->q++; 
} 


Foo * FooNew() 
{ 
    Foo * foo = malloc(sizeof(Foo)); 
    foo->q = 1; 
    foo->Bar = &Bar; 
} 

int main() 
{ 
    Foo *f = FooNew(); 
    Foo *g = FooNew(); 


    foo(f)->Bar(); 
    foo(f)->Bar(); 
    foo(f)->Bar(); 

    foo(g)->Bar(); 
    foo(g)->Bar(); 
    foo(g)->Bar(); 

    return 0; 
}