¿Sobrecarga de la función estática?

Question

Voy a empezar diciendo que entiendo que sólo las funciones miembro que no pueden ser virtuales, pero esto es lo que quiero:

1. Una clase base que define una interfaz: para que pueda utilizar punteros clase base para acceder a funciones .

2. Para la administración de la memoria (este es un sistema integrado con memoria RAM limitada) deseo que las funciones primordiales se asignen estáticamente. Acepto la consecuencia de que con una función estática, habrá restricciones sobre cómo puedo manipular datos en la función.

   Mi pensamiento actual es que puedo mantener una función de sobrecarga ligera haciendo que sea una envoltura para una función que en realidad es estática.

Por favor, por favor dime que necesito volver a pensar en mi diseño. Es por eso que estoy haciendo la pregunta. Si desea decirme que me conviene más usar c y usar devoluciones de llamada, por favor diríjase a algún material de lectura para explicar los peligros de usar un enfoque orientado a objetos. ¿Hay un patrón de diseño orientado a objetos que cumpla con los requisitos que he enumerado?

Answer 1

¿Hay un patrón de diseño orientado a objetos que cumpla con los requisitos que he enumerado?

Sí, simples funciones virtuales antiguas. Su deseo es "las funciones primordiales para ser asignadas estáticamente". Las funciones virtuales son estáticamente asignadas. Es decir, el código que implementa las funciones existe una vez, y solo una vez, y se fija en el tiempo de compilación/enlace. Según el comando del vinculador, es probable que se almacenen en flash como cualquier otra función.

class I { 
    public: 
    virtual void doit() = 0; 
    virtual void undoit() = 0; 
}; 

class A : public I { 
    public: 
    virtual void doit() { 
    // The code for this function is created statically and stored in the code segment 
    std::cout << "hello, "; 
    } 
    virtual void undoit() { 
    // ditto for this one 
    std::cout << "HELLO, "; 
    } 
}; 

class B : public I { 
    public: 
    int i; 
    virtual void doit() { 
    // ditto for this one 
    std::cout << "world\n"; 
    } 
    virtual void undoit() { 
    // yes, you got it. 
    std::cout << "WORLD\n"; 
    } 
}; 

int main() { 
    B b; // So, what is stored inside b? 
     // There are sizeof(int) bytes for "i", 
     // There are probably sizeof(void*) bytes for the vtable pointer. 
     // Note that the vtable pointer doesn't change size, regardless of how 
     // many virtual methods there are. 
     // sizeof(b) is probably 8 bytes or so. 
} 

Answer 2

Las funciones de miembro estático son simplemente funciones simples (como funciones no miembro), que están dentro del espacio de nombres de la clase. Esto significa que puede tratarlos como funciones de fricción, y la siguiente solución debe hacer:

class Interface 
{ 
    public: 
    void (*function)(); 
}; 

class Implementation: public Interface 
{ 
    public: 
    Implementation() 
    { 
     function = impl_function; 
    } 

    private: 
    static void impl_function() 
    { 
     // do something 
    } 
}; 

continuación

Implementation a; 
Interface* b = &a; 
b->function(); // will do something... 

El problema con este enfoque es que usted estaría haciendo casi lo que hace el compilador para usted cuando usa funciones miembro virtuales, simplemente mejor (necesita menos código, es menos propenso a errores y el puntero a las funciones de implementación se comparten). La principal diferencia es que al usar virtual su función recibiría el parámetro (invisible) this cuando se le llamara, y usted podría acceder a las variables miembro.

Por lo tanto, le recomendaría que simplemente no haga esto, y utilice métodos virtuales ordinarios.

Answer 3

A efectos de gestión de memoria (esto es un sistema embebido con RAM limitada) Quiero que las funciones primordiales sean asignados estáticamente .

Todas las funciones en C++ están siempre asignadas estáticamente. La única excepción es si descarga manualmente y utiliza un JIT.

Answer 4

La sobrecarga con funciones virtuales es doble: además del código para las implementaciones reales (que reside en el segmento de código, al igual que cualquier otra función que escriba), existe la tabla de funciones virtuales, y hay punteros a esa mesa. La tabla de funciones virtuales está presente una vez para cada clase derivado, y su tamaño depende del número de funciones virtuales. Cada objeto debe llevar un puntero a su tabla de funciones virtuales.

Mi punto es que la sobrecarga por objeto de las funciones virtuales es la misma sin importar cuántas funciones virtuales tenga o cuánto código contenga. Por lo tanto, la forma en que organice sus funciones virtuales debería tener poco impacto en el consumo de su memoria, una vez que haya decidido que desea algún grado de polimorfismo.