wartość domyślna dla elementu członkowskiego struktury w C

Czy można ustawić wartości domyślne dla jakiegoś elementu członkowskiego struktury? Próbowałem następujących rzeczy, ale spowodowałoby to błąd składni:

typedef struct
{
  int flag = 3;
} MyStruct;

Błędy:

$ gcc -o testIt test.c 
test.c:7: error: expected ‘:’, ‘,’, ‘;’, ‘}’ or ‘__attribute__’ before ‘=’ token
test.c: In function ‘main’:
test.c:17: error: ‘struct <anonymous>’ has no member named ‘flag’

Struktura to typ danych . Nie nadajesz wartości typowi danych. Nadajesz wartości instancjom / obiektom typów danych.
Więc nie, to nie jest możliwe w C.

Zamiast tego możesz napisać funkcję, która wykonuje inicjalizację dla instancji struktury.

Alternatywnie możesz zrobić:

struct MyStruct_s 
{
    int id;
} MyStruct_default = {3};

typedef struct MyStruct_s MyStruct;

Następnie zawsze inicjalizuj nowe instancje jako:

MyStruct mInstance = MyStruct_default;

nie możesz tego zrobić w ten sposób

Zamiast tego użyj następujących

typedef struct
{
   int id;
   char* name;
}employee;

employee emp = {
.id = 0, 
.name = "none"
};

Możesz użyć makra do definiowania i inicjowania swoich instancji. Ułatwi ci to za każdym razem, gdy będziesz chciał zdefiniować nową instancję i zainicjować ją.

typedef struct
{
   int id;
   char* name;
}employee;

#define INIT_EMPLOYEE(X) employee X = {.id = 0, .name ="none"}

a w swoim kodzie, gdy musisz zdefiniować nową instancję z typem pracownika, po prostu wywołaj to makro w następujący sposób:

INIT_EMPLOYEE(emp);

Zgadzam się z Alsem, że nie możesz zainicjować w momencie definiowania struktury w C. Ale możesz zainicjować strukturę w momencie tworzenia instancji pokazanej poniżej.

W C,

 struct s {
        int i;
        int j;
    };

    struct s s_instance = { 10 ,20 };

w C ++ można podać bezpośrednią wartość w definicji struktury pokazanej poniżej

struct s {
    int i;

    s(): i(10)
    {
    }
};

Możesz to zrobić:

struct employee_s {
  int id;
  char* name;
} employee_default = {0, "none"};

typedef struct employee_s employee;

A potem musisz tylko pamiętać, aby wykonać domyślną inicjalizację podczas deklarowania nowej zmiennej pracownika:

employee foo = employee_default;

Alternatywnie możesz zawsze zbudować strukturę pracownika za pomocą funkcji fabryki.

Jeśli używasz gcc, możesz dać designated initializersw tworzeniu obiektów.

typedef struct
{
   int id=0;
   char* name="none";
}employee;

employee e = 
{
 .id = 0;
 .name = "none";
};

Lub po prostu użyj podobnej inicjalizacji tablicy.

employee e = {0 , "none"};

Utwórz domyślną strukturę, jak wspomniały inne odpowiedzi:

struct MyStruct
{
    int flag;
}

MyStruct_default = {3};

Jednakże powyższy kod nie zadziała w pliku nagłówkowym - dostaniesz błąd: multiple definition of 'MyStruct_default'. Aby rozwiązać ten problem, użyj externzamiast tego w pliku nagłówkowym:

struct MyStruct
{
    int flag;
};

extern const struct MyStruct MyStruct_default;

A w cpliku:

const struct MyStruct MyStruct_default = {3};

Mam nadzieję, że pomoże to każdemu, kto ma problemy z plikiem nagłówkowym.

Co więcej, aby dodać istniejące odpowiedzi, możesz użyć makra, które ukrywa inicjator struktury:

#define DEFAULT_EMPLOYEE { 0, "none" }

Następnie w swoim kodzie:

employee john = DEFAULT_EMPLOYEE;

Możesz zaimplementować funkcję inicjalizacyjną:

employee init_employee() {
  empolyee const e = {0,"none"};
  return e;
}

Możesz użyć jakiejś funkcji do zainicjowania struktury w następujący sposób,

typedef struct
{
    int flag;
} MyStruct;

MyStruct GetMyStruct(int value)
{
    MyStruct My = {0};
    My.flag = value;
    return My;
}

void main (void)
{
    MyStruct temp;
    temp = GetMyStruct(3);
    printf("%d\n", temp.flag);
}

EDYTOWAĆ:

typedef struct
{
    int flag;
} MyStruct;

MyStruct MyData[20];

MyStruct GetMyStruct(int value)
{
    MyStruct My = {0};
    My.flag = value;
    return My;
}

void main (void)
{
    int i;
    for (i = 0; i < 20; i ++)
        MyData[i] = GetMyStruct(3);

    for (i = 0; i < 20; i ++)
        printf("%d\n", MyData[i].flag);
}

Dla maksymalnej wygody można używać kombinacji funkcji preprocesora C z varargami , literałami złożonymi i wyznaczonymi inicjatorami :

typedef struct {
    int id;
    char* name;
} employee;

#define EMPLOYEE(...) ((employee) { .id = 0, .name = "none", ##__VA_ARGS__ })

employee john = EMPLOYEE(.name="John");  // no id initialization
employee jane = EMPLOYEE(.id=5);         // no name initialization

Jeśli użyjesz tej struktury tylko raz , tj. Utworzysz zmienną globalną / statyczną, możesz natychmiast usunąć typedefi zainicjować tę zmienną:

struct {
    int id;
    char *name;
} employee = {
    .id = 0,
    .name = "none"
};

Następnie możesz użyć employeew swoim kodzie.

Funkcja inicjująca do struktury to dobry sposób na nadanie jej domyślnych wartości:

Mystruct s;
Mystruct_init(&s);

Albo jeszcze krócej:

Mystruct s = Mystruct_init();  // this time init returns a struct

Inne podejście do wartości domyślnych. Utwórz funkcję inicjalizującą o tym samym typie co struktura. Takie podejście jest bardzo przydatne podczas dzielenia dużego kodu na osobne pliki.

struct structType{
  int flag;
};

struct structType InitializeMyStruct(){
    struct structType structInitialized;
    structInitialized.flag = 3;
    return(structInitialized); 
};


int main(){
    struct structType MyStruct = InitializeMyStruct();
};

Możesz stworzyć dla niego funkcję:

typedef struct {
    int id;
    char name;
} employee;

void set_iv(employee *em);

int main(){
    employee em0; set_iv(&em0);
}

void set_iv(employee *em){
    (*em).id = 0;
    (*em).name = "none";
}

Innym podejściem, jeśli pozwala na to struktura, jest użycie #define z domyślnymi wartościami wewnątrz:

#define MYSTRUCT_INIT { 0, 0, true }

typedef struct
{
    int id;
    int flag;
    bool foo;
} MyStruct;

Posługiwać się:

MyStruct val = MYSTRUCT_INIT;

Myślę, że możesz to zrobić w następujący sposób,

typedef struct
{
  int flag : 3;
} MyStruct;