Приведение указателя void во время выполнения

Чтобы ->a работало, компилятор должен знать расположение (помимо прочего) поля относительно указателя. Это смещение должно быть постоянным в C.

Мы можем добиться этой цели, сделав ваши два типа совместимыми с третьим и используя этот третий тип (Base).

typedef struct {
   A a;
   B b;
} Base;

typedef struct {
   Base base;
   …
} Unif;

typedef struct {
   Base base;
   …
} Kmeans;

// `base` doesn't need to be the first field of `Unif` and `Kmeans`
// (unless you want to recuperate the orig ptr from a `Base *` at some point).

void foo( Base *ptr, … ) {
   ptr->a = bar( … );
   ptr->b = baz( … );
}

Unif *unif = …;
foo( &unif->base, … );

Kmeans *kmeans = …;
foo( &kmeans->base, … );

Это менее безопасно, но мы могли бы назвать его и так:

// `base` must be the first field of `Unif` and `Kmeans`.

void foo( Base *ptr, … ) {
   ptr->a = bar( … );
   ptr->b = baz( … );
}

Unif *unif = …;
foo( (Base *)unif, … );

Kmeans *kmeans = …;
foo( (Base *)kmeans, … );

Это означает, что мы можем внести несколько изменений, чтобы немного сократить код, необходимый для вызывающей программы.

// `base` must be the first field of `Unif` and `Kmeans`.

void foo( void *ptr_, … ) {
   Base *ptr = ptr_;
   ptr->a = bar( … );
   ptr->b = baz( … );
}

Unif *unif = …;
foo( unif, … );

Kmeans *kmeans = …;
foo( kmeans, … );

Последние два не так безопасны, как оригинал, поскольку они обходят проверки типов посредством явного и неявного приведения типов.

Но это не работает, поскольку объявление my_ptr находится внутри области действия переключателя.

Это не работает, но не только из-за декларации my_ptr. Нельзя просто пересылать ...

Я покажу пример, который может делать или не делать то, что вы хотите. Я не уверен, что понимаю, что вам нужно. В любом случае, если вам нужен диспактер, основанный на типе и указателе, этот может подойти.
Если функции используют аргументы одного и того же типа, работает простой 5-строчный VFT, индексированный по типу.

Пример

Основы

typedef enum
{
    UNIF,
    KMEANS
} Class_t;

typedef struct
{
    void        (*bar)(const char*, unsigned, ...);
} UNIF_t;

typedef struct
{
    void        (*baz)(const char*, unsigned, ...);
} KMEANS_t;

// the dispatcher
void     foo(Class_t type, void* ptr, unsigned N, ...);

main для этого примера

Для тестирования:

• UNIF_t реализует bar. Пример bar здесь получает строку для идентификатора и (вариативного) некоторого int и просто отображает значения.
• KMEANS_t реализует baz. Пример baz здесь получает строку для идентификатора и (вариативного) некоторого char* и просто отображает значения.

int main(void)
{
    UNIF_t   unif   = {.bar=for_unif};
    KMEANS_t kmeans = {.baz=for_kmeans};

    void* p = &unif;
    foo(UNIF, p, 4, 1, 2, 3, 4);
    foo(KMEANS, &kmeans, 3, "Stack", "Overflow", "C");

    p = &kmeans;
    foo(KMEANS, p, 2, "What", "if?");
    foo(UNIF, &unif, 8, 8, 7, 6, 5, 4, 3, 2, 1);
    return 0;
}

Логика тривиальна:

• создается struct каждого вида
• пара указатель/тип используется для вызова диспетчера foo()
• диспетчер вызывает необходимый метод

foo()

    void foo(Class_t type, void* ptr, unsigned N, ...)
    {
        va_list parms;
        va_start(parms, N);
        switch (type)
        {
            case UNIF:
            {
                ((UNIF_t*)ptr)->bar("testing for UNIF", N, parms);
                break;
            }
            case KMEANS:
            {
                ((KMEANS_t*)ptr)->baz("testing for KMEANS", N, parms);
                break;
            }
            default:
                fprintf(stderr, "Invalid Type 0x%X!\n", type);
                break;
        };  // switch()
        va_end(parms);
    }

Это своего рода C++ функтор. Здесь написано так, потому что я предполагаю, что в структурах больше данных. Если нет, то простой VFT, индексированный по типу, работает нормально.

Единственное, что здесь не распространено, — это построение va_list для использования во внутренних функциях.

выход

UNIF: id is 'testing for UNIF', 4 args
        args: (1,2,3,4)

KMEANS: id is 'testing for KMEANS', 3 args
 1: 'Stack'
 2: 'Overflow'
 3: 'C'

KMEANS: id is 'testing for KMEANS', 2 args
 1: 'What'
 2: 'if?'

UNIF: id is 'testing for UNIF', 8 args
        args: (8,7,6,5,4,3,2,1)

полный код примера

#include <stdarg.h>
#include <stdio.h>

typedef enum
{
    UNIF,
    KMEANS
} Class_t;

typedef struct
{
    void (*bar)(const char*, unsigned, ...);
} UNIF_t;

typedef struct
{
    void (*baz)(const char*, unsigned, ...);
} KMEANS_t;

// the dispatcher
void foo(Class_t type, void* ptr, unsigned N, ...);

// functions for testing these 'classes'
void for_unif (const char*, unsigned N, va_list parms);
void for_kmeans(const char*, unsigned, va_list parms);

int main(void)
{
    UNIF_t   unif   = {.bar = for_unif};
    KMEANS_t kmeans = {.baz = for_kmeans};

    void* p = &unif;
    foo(UNIF, p, 4, 1, 2, 3, 4);
    foo(KMEANS, &kmeans, 3, "Stack", "Overflow", "C");

    p = &kmeans;
    foo(KMEANS, p, 2, "What", "if?");
    foo(UNIF, &unif, 8, 8, 7, 6, 5, 4, 3, 2, 1);

    return 0;
}

void for_unif (const char* id, unsigned N, va_list parms)
{
    printf("\nUNIF: id is '%s', %d args\n\targs: (", id, N);
    for (size_t i = 0; i < N - 1; i += 1)
        printf("%d,", va_arg(parms, int));
    printf("%d)\n", va_arg(parms, int));
    return;
}

void for_kmeans(const char* id, unsigned N, va_list parms)
{
    printf("\nKMEANS: id is '%s', %d args\n", id, N);
    for (unsigned i = 0; i < N; i += 1)
        printf("%2u: '%s'\n", 1 + i, va_arg(parms, char*));
    return;
}

void foo(Class_t type, void* ptr, unsigned N, ...)
{
    va_list parms;
    va_start(parms, N);
    switch (type)
    {
        case UNIF:
        {
            ((UNIF_t*)ptr)
                ->bar("testing for UNIF", N, parms);
            break;
        }
        case KMEANS:
        {
            ((KMEANS_t*)ptr)
                ->baz("testing for KMEANS", N, parms);
            break;
        }
        default:
            fprintf(stderr, "Invalid Type 0x%X!\n", type);
            break;
    };  // switch()
    va_end(parms);
}

больше из исходного вопроса

void foo(void* ptr, quant_t type, ...){
void* my_ptr = NULL;
switch(type){
case UNIF:{
my_ptr = (struct unif*) ptr;
break;
}
case KMEANS:{
my_ptr = (struct kmeans*) ptr;
break;
}...}

my_ptr->a = bar(...);
my_ptr->b = baz(...);
}

если my_ptr есть void*, то my_ptr->a или my_ptr_b не имеют смысла.

Поскольку bar и baz имеют одинаковую подпись, если все, что вы можете, это просто использовать my_ptr для вызова функции внутри struct unif или struct kmeans, в зависимости от типа, это может быть даже проще, фактически однострочным: F[type](descr[type], N, parms); используя foo, как показано ниже:

foo() как однострочник

void foo(Class_t type, void* ptr, unsigned N, ...)
{
    va_list parms;
    va_start(parms, N);
    // clang-format off
    const char* descr[] = {
        [UNIF]= "type is UNIF",[KMEANS]= "type is KMEANS"};
        void(*F[])(const char* id, unsigned N, va_list parms) = {
        [UNIF]   = ((UNIF_t*)ptr)->bar,
        [KMEANS] = ((KMEANS_t*)ptr)->baz
    };
 
    F[type](descr[type], N, parms);
    va_end(parms);
}

Если внутри structs больше ничего не нужно и нужен только метод, это всего лишь таблица функций, индексированная type: она работает так же, как в примере выше.

пример 2

#include <stdarg.h>
#include <stdio.h>

typedef enum
{
    UNIF,
    KMEANS
} Class_t;

typedef struct
{
    void (*bar)(const char*, unsigned, ...);
} UNIF_t;

typedef struct
{
    void (*baz)(const char*, unsigned, ...);
} KMEANS_t;

// the dispatcher
void foo(Class_t type, void* ptr, unsigned N, ...);

// functions for testing these 'classes'
void for_unif (const char*, unsigned N, va_list parms);
void for_kmeans(const char*, unsigned, va_list parms);

int main(void)
{
    UNIF_t   unif   = {.bar = for_unif};
    KMEANS_t kmeans = {.baz = for_kmeans};

    void* p = &unif;
    foo(UNIF, p, 4, 1, 2, 3, 4);
    foo(KMEANS, &kmeans, 3, "Stack", "Overflow", "C");

    p = &kmeans;
    foo(KMEANS, p, 2, "What", "if?");
    foo(UNIF, &unif, 8, 8, 7, 6, 5, 4, 3, 2, 1);

    return 0;
}

void for_unif (const char* id, unsigned N, va_list parms)
{
    printf("\nUNIF: id is '%s', %d args\n\targs: (", id, N);
    for (size_t i = 0; i < N - 1; i += 1)
        printf("%d,", va_arg(parms, int));
    printf("%d)\n", va_arg(parms, int));
    return;
}

void for_kmeans(const char* id, unsigned N, va_list parms)
{
    printf("\nKMEANS: id is '%s', %d args\n", id, N);
    for (unsigned i = 0; i < N; i += 1)
        printf("%2u: '%s'\n", 1 + i, va_arg(parms, char*));
    return;
}

void foo(Class_t type, void* ptr, unsigned N, ...)
{
    va_list parms;
    va_start(parms, N);
    // clang-format off
    const char* descr[] = {
        [UNIF]= "type is UNIF",[KMEANS]= "type is KMEANS"};
        void(*F[])(const char* id, unsigned N, va_list parms) = {
        [UNIF]   = ((UNIF_t*)ptr)->bar,
        [KMEANS] = ((KMEANS_t*)ptr)->baz
    };
    // clang-format on

    F[type](descr[type], N, parms);
    va_end(parms);
}

https://stackoverflow.com/questions/78081529/runtime-cast-of-void-pointer