Let's say for example that I have defined a struct emp_t. Then, I want all employees (objects) created from that structure to have ID = 0, name = "Empty string", and salary = 0. Is this possible?
struct employee
{
int id;
char name [30];
int salary;
};
typedef struct employee emp_t;
One sensible way of doing it is via function. When you have you employee structure, you can do:
void employee_init(struct employee* p)
{
p->id = 0;
p->name[0] = '\0';
p->salary = 2000;
}
You can also use a simple macro:
#include <stdio.h>
typedef struct {
int id;
char name[30];
int salary;
} Employee;
#define EMPLOYEE(var) \
Employee var; \
var.id = 0; \
var.name[0] = '\0'; \
var.salary = 0;
int main()
{
EMPLOYEE(john);
printf("%d %s %d\n", john.id, john.name, john.salary);
return 0;
}
Or combine both:
#define EMPLOYEE(var) \
Employee var; \
employee_init(&var);
When you use malloc():
#define EMPLOYEE_DYN(var, n) \
Employee* var = malloc(sizeof(Employee) * n); \
employee_init(var);
Since C99 you can also do:
#define EMPLOYEE(var) \
Employee var = { .id = 0, .name = "", .salary = 0 }
More constructor-like macro (in this case #include <string.h> will be needed):
#define EMPLOYEE(var, id_, name_, salary_) \
Employee var; \
var.id = id_; \
strcpy(var.name, name_); \
var.salary = salary_;
Or with designated initializer:
#define EMPLOYEE(var, id_, name_, salary_) \
Employee var = { .id = id_, .name = name_, .salary = salary_ }
Preliminary note: member name of your structure is an array, not a pointer. NULL is not a valid value for it. The value it would be initialized with by default initialization is all(30)-bytes-zero, which is an entirely different thing.
With that said, you get default initialization by, um, default for objects declared with static storage duration. That is, all those declared at file scope and those declarared at block scope with the keyword static. For those cases you don't need to do anything special.
// at file scope
struct employee emp1; // done
int do_something() {
static struct employee emp2; // done (but any changes persist across calls)
// ...
return 0;
}
For those with automatic storage duration -- that is, block-scope variables that are not static -- you need to provide an initializer. It is important here to understand that
0 can be used to initialize any scalar, and the result is the same as what default initialization would achieve; andWhat that all means is that you can achieve manual initialization equivalent to default initialization for any object via the initializer {0} (though be careful here with arrays of unspecified length). In particular, this is utterly idiomatic:
int do_something_else() {
struct employee emp3 = {0};
// ...
return 0;
}
Note well that initialization is not assignment! That syntax is not (quite) valid for an assignment statement.
And that brings us around to the last case: allocated objects. These are not subject to default initialization and they cannot have initializers. It is fairly common to set initial values for these by setting them to all bytes zero, either by allocating them with calloc() or by zero-filling them after allocation with memset(). Neither of those approaches supports strictly conforming programs in all cases, however, because pointer and floating-point object representations with all bits zero are not necessarily the same as you get from default initialization of such objects.
You can always just assign appropriate values to each member individually, but in modern C, the cleanest thing to do to set an allocated structure's value as if it had been default initialized is to assign an appropriate a compound literal value to it:
int do_a_third_thing() {
struct employee *ep = malloc(sizeof(*ep));
// ... check for / handle NULL ...
*ep = (struct employee) {0}; // HERE
// ...
return 0;
}
In that example, the expression (struct employee) {0} has type struct employee and (initial) value as if it were declared with an initializer of {0}.
Of course, you can do the same thing to assign a new, as-if-default-initialized value to any structure or union object, regardless of its storage duration.
With all that said, the bottom line answer to
I want all employees (objects) created from that structure to have ID = 0, name = NULL, and salary = 0. Is this possible?
Is no, it is not possible per se. C does not have constructors, default or otherwise. As I have shown, however, if default initialization is what a user wants for a particular instance, then it is fairly easy for them to get it. And if it's not what they want, then it is not useful to force that on them.
Here's another way, using a 'prototype' approach.
# include <stdlib.h>
# include <string.h>
# include <stdio.h>
struct employee {
int id;
char name [30];
int salary;
};
struct employee const * const create_employee_prototype() {
struct employee * prototype = (struct employee *) malloc( sizeof(struct employee) );
prototype->id = 0;
for (int i = 0; i < 30; ++i) { prototype->name[i] = 0; }
prototype->salary = 0;
return (struct employee const * const) prototype;
}
struct employee * generate_new_employee_from_prototype( struct employee const * const prototype ) {
struct employee * employee_out = malloc( sizeof( struct employee ) );
employee_out = memcpy( employee_out, prototype, sizeof( struct employee ) );
return employee_out;
}
int main() {
struct employee const * const PROTOTYPE = create_employee_prototype();
struct employee * employee1 = generate_new_employee_from_prototype( PROTOTYPE );
printf( "Employee 1 initialised with id: %d, name: %s, and salary: %d.\n", employee1->id, employee1->name, employee1->salary );
free( employee1 );
free( (void *) PROTOTYPE );
}
Effectively create a constant object in memory that you can generate copies of. Disadvantage: generated on the heap in a 'non-visible' way, so you need to know/remember to free the memory manually. (obviously you're free to adapt this to use the stack instead.)
