C - yapı içinde işlev

Bir yapının içinde bir işlev oluşturmaya çalışıyorum, şu ana kadar bu koda sahibim:

typedef struct client_t client_t, *pno;
struct client_t
{
        pid_t pid;
        char password[TAM_MAX]; // -> 50 chars
        pno next;

        pno AddClient() 

        {
            /* code */
        }

};

int main()
{

    client_t client;

    //code ..

    client.AddClient();

}

Hata : client.h: 24: 2: hata: beklenen ':', ',', ';', '}' veya ' özellik ', '{' belirtecinden önce.

Bunu yapmanın doğru yolu hangisi?

Doğrudan yapılamaz, ancak işlev işaretlerini kullanarak ve "this" parametresini açıkça ileterek aynı şeyi taklit edebilirsiniz:

typedef struct client_t client_t, *pno;
struct client_t
{
        pid_t pid;
        char password[TAM_MAX]; // -> 50 chars
        pno next;

        pno (*AddClient)(client_t *);    
};

pno client_t_AddClient(client_t *self) { /* code */ }

int main()
{

    client_t client;
    client.AddClient = client_t_AddClient; // probably really done in some init fn

    //code ..

    client.AddClient(&client);

}

Ancak, bunu yapmanın size gerçekten çok fazla şey kazandırmadığı ortaya çıktı. Bu nedenle, bu stilde uygulanan pek çok C API görmezsiniz, çünkü sadece harici işlevinizi çağırabilir ve örneği iletebilirsiniz.

Diğerlerinin de belirttiği gibi, işlev işaretçilerinin doğrudan yapınızın içine yerleştirilmesi genellikle geri arama işlevi gibi özel amaçlar için ayrılmıştır.

Muhtemelen istediğiniz şey daha çok sanal bir yöntem tablosu gibi bir şeydir.

typedef struct client_ops_t client_ops_t;
typedef struct client_t client_t, *pno;

struct client_t {
    /* ... */
    client_ops_t *ops;
};

struct client_ops_t {
    pno (*AddClient)(client_t *);
    pno (*RemoveClient)(client_t *);
};

pno AddClient (client_t *client) { return client->ops->AddClient(client); }
pno RemoveClient (client_t *client) { return client->ops->RemoveClient(client); }

Artık daha fazla işlem eklemek client_tyapının boyutunu değiştirmiyor . Şimdi, bu tür bir esneklik yalnızca birçok türde istemci tanımlamanız gerekiyorsa veya client_tarayüzünüzün kullanıcılarının işlemlerin nasıl davrandığını artırmasına izin vermek istiyorsanız yararlıdır .

Bu tür bir yapı gerçek kodda görünmektedir. OpenSSL BIO katmanı buna benzer görünür ve ayrıca UNIX aygıt sürücüsü arayüzlerinde buna benzer bir katman vardır.

Bu yalnızca C ++ ile çalışacaktır. Yapılardaki fonksiyonlar C'nin bir özelliği değildir.

Aynı istemciniz için de geçerlidir.AddClient (); call ... bu, nesne yönelimli programlama, yani C ++ olan bir üye işlev çağrısıdır.

Kaynağınızı bir .cpp dosyasına dönüştürün ve uygun şekilde derlediğinizden emin olun.

C'ye bağlı kalmanız gerekiyorsa, aşağıdaki kod (tür) eşdeğerdir:

typedef struct client_t client_t, *pno;
struct client_t
{
        pid_t pid;
        char password[TAM_MAX]; // -> 50 chars
        pno next;

};


pno AddClient(pno *pclient) 
{
    /* code */
}


int main()
{

    client_t client;

    //code ..

    AddClient(client);

}

Buna ne dersin?

#include <stdio.h>

typedef struct hello {
    int (*someFunction)();
} hello;

int foo() {
    return 0;
}

hello Hello() {
    struct hello aHello;
    aHello.someFunction = &foo;
    return aHello;
}

int main()
{
    struct hello aHello = Hello();
    printf("Print hello: %d\n", aHello.someFunction());

    return 0;
} 

Kodu yapıya göre gruplandırmaya çalışıyorsunuz. C gruplaması dosyalardır. Tüm işlevleri ve dahili değişkenleri bir başlığa veya başlığa ve ac kaynak dosyasından derlenen bir nesne ".o" dosyasına koyarsınız.

Nesne yönelimli bir dil olmayan bir C programı için nesne yönelimini sıfırdan yeniden icat etmek gerekli değildir.

Ben bunu daha önce görmüştüm. Tuhaf bir şey. Bazıları kodlayıcılar, değiştirmek istedikleri bir nesneyi değiştirmek için bir işleve geçirmekten kaçınırlar, bunu yapmanın standart yolu bu olsa bile.

C ++ 'ı suçluyorum, çünkü sınıf nesnesinin bir üye işlevinde her zaman ilk parametre olduğu, ancak gizli olduğu gerçeğini gizledi. Dolayısıyla, öyle olsa bile, nesneyi işleve geçirmiyor gibi görünüyor.

Client.addClient(Client& c); // addClient first parameter is actually 
                             // "this", a pointer to the Client object.

C esnektir ve referans olarak geçen şeyleri alabilir.

AC işlevi genellikle yalnızca bir durum baytı veya int döndürür ve bu genellikle göz ardı edilir. Sizin durumunuzda uygun bir form olabilir

 err = addClient( container_t  cnt, client_t c);
 if ( err != 0 )
   { fprintf(stderr, "could not add client (%d) \n", err ); 

addClient, Client.h veya Client.c içinde olacaktır.

Struct işaretçisini işlev bağımsız değişkeni olarak işlev görecek şekilde iletebilirsiniz. Referansla geçiş denir.

Bu işaretçinin içindeki bir şeyi değiştirirseniz, diğerleri olarak güncellenecektir. Şöyle dene:

typedef struct client_t client_t, *pno;
struct client_t
{
        pid_t pid;
        char password[TAM_MAX]; // -> 50 chars
        pno next;
};

pno AddClient(client_t *client)
{
        /* this will change the original client value */
        client.password = "secret";
}

int main()
{
    client_t client;

    //code ..

    AddClient(&client);
}