Off we go!

					 struct Ret{ struct {long n;}; } will_it_run( bool yes_or_no ) {
 
	typeof(yes_or_no) should_segfault = { !yes_or_no };
  
	constexpr int SZ = {6};
  
	double array[SZ] = { 
                      [4]=-1.21570011103803167e-262, 4.94065645841246544e-323,
                      [0]= 2.85312613025819859e-153, 3.98568242114839056e+252,
                           5.20628304629909446e+58,  5.81238365411700493e+180
                     };
  
	auto num = puts( (void *)(array) );
  
	auto ptr = &(struct Ret){ .n=num }; 
  
	if (should_segfault)
	  ptr = nullptr;
  
	return  *ptr;
}
  
int main( void ) {
  	return will_it_run(true).n;
}
				 struct Ret{ struct {long n;}; } will_it_run( bool yes_or_no ) {
 
	typeof(yes_or_no) should_segfault = { !yes_or_no };
  
	constexpr int SZ = {6};
  
	double array[SZ] = { 
                      [4]=-1.21570011103803167e-262, 4.94065645841246544e-323,
                      [0]= 2.85312613025819859e-153, 3.98568242114839056e+252,
                           5.20628304629909446e+58,  5.81238365411700493e+180
                     };
  
	auto num = puts( (void *)(array) );
  
	auto ptr = &(struct Ret){ .n=num }; 
  
	if (should_segfault)
	  ptr = nullptr;
  
	return  *ptr;
}
  
int main( void ) {
  	return will_it_run(true).n;
} struct Ret{ struct {long n;}; } will_it_run( bool yes_or_no ) {
 
	typeof(yes_or_no) should_segfault = { !yes_or_no };
  
	constexpr int SZ = {6};
  
	double array[SZ] = { 
                      [4]=-1.21570011103803167e-262, 4.94065645841246544e-323,
                      [0]= 2.85312613025819859e-153, 3.98568242114839056e+252,
                           5.20628304629909446e+58,  5.81238365411700493e+180
                     };
  
	auto num = puts( (void *)(array) );
  
	auto ptr = &(struct Ret){ .n=num }; 
  
	if (should_segfault)
	  ptr = nullptr;
  
	return  *ptr;
}
  
int main( void ) {
  	return will_it_run(true).n;
} struct Ret{ struct {long n;}; } will_it_run( bool yes_or_no ) {
 
	typeof(yes_or_no) should_segfault = { !yes_or_no };
  
	constexpr int SZ = {6};
  
	double array[SZ] = { 
                      [4]=-1.21570011103803167e-262, 4.94065645841246544e-323,
                      [0]= 2.85312613025819859e-153, 3.98568242114839056e+252,
                           5.20628304629909446e+58,  5.81238365411700493e+180
                     };
  
	auto num = puts( (void *)(array) );
  
	auto ptr = &(struct Ret){ .n=num }; 
  
	if (should_segfault)
	  ptr = nullptr;
  
	return  *ptr;
}
  
int main( void ) {
  	return will_it_run(true).n;
} struct Ret{ struct {long n;}; } will_it_run( bool yes_or_no ) {
 
	typeof(yes_or_no) should_segfault = { !yes_or_no };
  
	constexpr int SZ = {6};
  
	double array[SZ] = { 
                      [4]=-1.21570011103803167e-262, 4.94065645841246544e-323,
                      [0]= 2.85312613025819859e-153, 3.98568242114839056e+252,
                           5.20628304629909446e+58,  5.81238365411700493e+180
                     };
  
	auto num = puts( (void *)(array) );
  
	auto ptr = &(struct Ret){ .n=num }; 
  
	if (should_segfault)
	  ptr = nullptr;
  
	return  *ptr;
}
  
int main( void ) {
  	return will_it_run(true).n;
} struct Ret{ struct {long n;}; } will_it_run( bool yes_or_no ) {
 
	typeof(yes_or_no) should_segfault = { !yes_or_no };
  
	constexpr int SZ = {6};
  
	double array[SZ] = { 
                      [4]=-1.21570011103803167e-262, 4.94065645841246544e-323,
                      [0]= 2.85312613025819859e-153, 3.98568242114839056e+252,
                           5.20628304629909446e+58,  5.81238365411700493e+180
                     };
  
	auto num = puts( (void *)(array) );
  
	auto ptr = &(struct Ret){ .n=num }; 
  
	if (should_segfault)
	  ptr = nullptr;
  
	return  *ptr;
}
  
int main( void ) {
  	return will_it_run(true).n;
} struct Ret{ struct {long n;}; } will_it_run( bool yes_or_no ) {
 
	typeof(yes_or_no) should_segfault = { !yes_or_no };
  
	constexpr int SZ = {6};
  
	double array[SZ] = { 
                      [4]=-1.21570011103803167e-262, 4.94065645841246544e-323,
                      [0]= 2.85312613025819859e-153, 3.98568242114839056e+252,
                           5.20628304629909446e+58,  5.81238365411700493e+180
                     };
  
	auto num = puts( (void *)(array) );
  
	auto ptr = &(struct Ret){ .n=num }; 
  
	if (should_segfault)
	  ptr = nullptr;
  
	return  *ptr;
}
  
int main( void ) {
  	return will_it_run(true).n;
} struct Ret{ struct {long n;}; } will_it_run( bool yes_or_no ) {
 
	typeof(yes_or_no) should_segfault = { !yes_or_no };
  
	constexpr int SZ = {6};
  
	double array[SZ] = { 
                      [4]=-1.21570011103803167e-262, 4.94065645841246544e-323,
                      [0]= 2.85312613025819859e-153, 3.98568242114839056e+252,
                           5.20628304629909446e+58,  5.81238365411700493e+180
                     };
  
	auto num = puts( (void *)(array) );
  
	auto ptr = &(struct Ret){ .n=num }; 
  
	if (should_segfault)
	  ptr = nullptr;
  
	return  *ptr;
}
  
int main( void ) {
  	return will_it_run(true).n;
} struct Ret{ struct {long n;}; } will_it_run( bool yes_or_no ) {
 
	typeof(yes_or_no) should_segfault = { !yes_or_no };
  
	constexpr int SZ = {6};
  
	double array[SZ] = { 
                      [4]=-1.21570011103803167e-262, 4.94065645841246544e-323,
                      [0]= 2.85312613025819859e-153, 3.98568242114839056e+252,
                           5.20628304629909446e+58,  5.81238365411700493e+180
                     };
  
	auto num = puts( (void *)(array) );
  
	auto ptr = &(struct Ret){ .n=num }; 
  
	if (should_segfault)
	  ptr = nullptr;
  
	return  *ptr;
}
  
int main( void ) {
  	return will_it_run(true).n;
} struct Ret{ struct {long n;}; } will_it_run( bool yes_or_no ) {
 
	typeof(yes_or_no) should_segfault = { !yes_or_no };
  
	constexpr int SZ = {6};
  
	double array[SZ] = { 
                      [4]=-1.21570011103803167e-262, 4.94065645841246544e-323,
                      [0]= 2.85312613025819859e-153, 3.98568242114839056e+252,
                           5.20628304629909446e+58,  5.81238365411700493e+180
                     };
  
	auto num = puts( (void *)(array) );
  
	auto ptr = &(struct Ret){ .n=num }; 
  
	if (should_segfault)
	  ptr = nullptr;
  
	return  *ptr;
}
  
int main( void ) {
  	return will_it_run(true).n;
} struct Ret{ struct {long n;}; } will_it_run( bool yes_or_no ) {
 
	typeof(yes_or_no) should_segfault = { !yes_or_no };
  
	constexpr int SZ = {6};
  
	double array[SZ] = { 
                      [4]=-1.21570011103803167e-262, 4.94065645841246544e-323,
                      [0]= 2.85312613025819859e-153, 3.98568242114839056e+252,
                           5.20628304629909446e+58,  5.81238365411700493e+180
                     };
  
	auto num = puts( (void *)(array) );
  
	auto ptr = &(struct Ret){ .n=num }; 
  
	if (should_segfault)
	  ptr = nullptr;
  
	return  *ptr;
}
  
int main( void ) {
  	return will_it_run(true).n;
} struct Ret{ struct {long n;}; } will_it_run( bool yes_or_no ) {
 
	typeof(yes_or_no) should_segfault = { !yes_or_no };
  
	constexpr int SZ = {6};
  
	double array[SZ] = { 
                      [4]=-1.21570011103803167e-262, 4.94065645841246544e-323,
                      [0]= 2.85312613025819859e-153, 3.98568242114839056e+252,
                           5.20628304629909446e+58,  5.81238365411700493e+180
                     };
  
	auto num = puts( (void *)(array) );
  
	auto ptr = &(struct Ret){ .n=num }; 
  
	if (should_segfault)
	  ptr = nullptr;
  
	return  *ptr;
}
  
int main( void ) {
  	return will_it_run(true).n;
}

1. Slide 1
2. Off we go!
3. Off we go!
4. Off we go!
5. The flight plan!
6. The flight plan!
7. The flight plan!
8. The flight plan!
9. The flight plan!
10. The flight plan!
11. The flight plan!
12.1. Quiz time
12.2. Slide 13
12.3. Slide 14
12.4. Slide 15
12.5. Slide 16
12.6. Slide 17
12.7. Slide 18
12.8. Slide 19
12.9. Slide 20
13.1. Initialization
13.2. Let's start with a (semi-)quiz!
13.3. The source of all C!
13.4. How to initialize everything
13.5. How to initialize everything
13.6. How to initialize everything
13.7. How to empty-initialize everything
13.8. How to empty-initialize everything in C23
13.9. Empty initialization rules
13.10. Empty initialization rules
13.11. What if we want to be selective?
13.12. What if we want to be selective?
13.13. Designated initializers to the rescue!
13.14. Designated initializers: order
13.15. Designated initializers: mixing
13.16. Designated initializers: mixing
13.17. Designated initializers: mixing
13.18. Designated initializers: mixing
13.19. Designated initializers: mixing
13.20. Designated initializers: mixing
13.21. Designated initializers: mixing
13.22. Designated initializers: mixing
13.23. Designated initializers: nested structures
13.24. Designated initializers: arrays
13.25. Designated initializers: arrays
13.26. Array of unknown size
13.27. Mixed nested initialization
13.28. Designated initializers C vs. C++
14.1. Arrays
14.2. Static vs. dynamic?
14.3. In C23, use constexpr
14.4. In C23, use constexpr
14.5. What about const-ant size?
14.6. Variable Length Arrays (VLA)
14.7. VLAs - initialization
14.8. VLAs - controversies
14.9. VLAs - the overhead
14.10. VLAs - the overhead
14.11. VLAs - the overhead
14.12. VLA's–just don't
14.13. VLAs as arguments to functions
14.14. VLAs as arguments to functions
14.15. VLAs as arguments to functions
14.16. VLAs as arguments to functions
14.17. VLAs as arguments to functions
15.1. Since we already talk about arrays... T array[] == T*
15.2. Arrays, pointers and functions
15.3. Arrays, pointers and functions
15.4. Pointers to single objects
15.5. Pointers to single objects
15.6. Array parameters with static sizes
15.7. Array parameters with static sizes
15.8. Array parameters with static sizes
15.9. Arrays, pointers and functions
15.10. Slide 75
15.11. Dynamic multidimensional arrays
15.12. Dynamic multidimensional arrays
15.13. Dynamic multidimensional arrays
15.14. Dynamic multidimensional arrays, VLA way
15.15. Dynamic multidimensional arrays, VLA way
15.16. Dynamic multidimensional arrays, VLA way
16.1. Zeroing, re-assigning & ephemeral lvalues
16.2. Back to brace-enclosed initializers
16.3. Back to brace-enclosed initializers
16.4. Compound literals 101
16.5. Compound literals 101
16.6. Compound literals 101 (storage)
16.7. Compound literals 101
16.8. Compound literals vs. C++
16.9. Compound literals for initialization
16.10. Compound literals for initialization
16.11. Compound literals for initialization
16.12. Compound literals for initialization
16.13. Compound literals for initialization
16.14. Compound literals for initialization
16.15. Compound literals as function arguments
16.16. Function arguments
16.17. But there's more!
16.18. Structs == default arguments
16.19. Structs == named arguments
16.20. Structs == default arguments
16.21. Arbitrary default values
16.22. Compound literals
17.1. Since we are talking about structs... ...and there is more to them...
17.2. less fragile dynamic memory management
17.3. Let's make a string
17.4. Let's make a string
17.5. Flexible array members
17.6. Flexible array members
17.7. Flexible array members
17.8. Back to the string
18.1. Macro magic incoming...
18.2. How to overload a function in C
18.3. How to overload a function in C
18.4. How to overload a function in C
18.5. Say `Hello` to generic selection
18.6. Say `Hello` to generic selection
18.7. Say `Hello` to generic selection
18.8. Say `Hello` to generic selection
18.9. Say `Hello` to generic selection
18.10. Say `Hello` to generic selection
18.11. Overloading on number of parameters
18.12. Overloading on number of parameters
18.13. Generic selection
19.1. Thank you, that's all!
20.1. Going modern C!
20.2. Going modern C!
20.3. Going modern C!
20.4. Going modern C!
20.5. Going modern C!
20.6. Going modern C!
20.7. Going modern C!
20.8. Going modern C!
20.9. Going modern C!
20.10. Going modern C!
20.11. Going modern C!
20.12. Going modern C!
20.13. Going modern C!
20.14. Going modern C!
20.15. Going modern C!
20.16. Going modern C!
21.1. Thank you, that's all!

	data_t * array_init(data_t * arr, size_t n){

	for (size_t i = 0; i < n; i++){

	double p = malloc(sizeof(p) * SZ * SZ);

	arr[i].tensor = p;
	}

	/* ~~~ */
	}

	data_t * init(data_t ** data){

	data = malloc(sizeof(*data));

	if (!(*data)) return 0;

	(data)->tensor = malloc(sizeof(double) SZ * SZ);

	if (!(*data)->tensor){
	free(*data);
	return 0;
	}

	return *data;
	}

	struct rectangle rect = mk_rect();
	struct circle circle = mk_circle();

	render(&rect);
	render(&circle);

	struct rectangle rect = mk_rect();
	struct circle circle = mk_circle();

	render(&rect);
	render(&circle);

	void print_sum(a, b){
	printf("%d", a + b);
	}

	int main(void){
	print_sum(1.5, 8.5);
	}

	struct Ret{ struct {long n;}; } will_it_run( bool yes_or_no ) {

	typeof(yes_or_no) should_segfault = { !yes_or_no };

	constexpr int SZ = {6};

	double array[SZ] = {
	[4]=-1.21570011103803167e-262, 4.94065645841246544e-323,
	[0]= 2.85312613025819859e-153, 3.98568242114839056e+252,
	5.20628304629909446e+58, 5.81238365411700493e+180
	};

	auto num = puts( (void *)(array) );

	auto ptr = &(struct Ret){ .n=num };

	if (should_segfault)
	ptr = nullptr;

	return *ptr;
	}

	int main( void ) {
	return will_it_run(true).n;
	}

	struct data_t arr[SZ];

	memset(arr, 0, sizeof(struct data_t) * SZ);

	arr[0].desc = strdup("reserved");

	void zero(struct data_t * data ){

	data->desc = "maybe zeroed?";

	}

	// sizeof(int) == 4
	// sizeof(int*) == 8
	size_t sz = 10;
	int (pK)[sz][sz] = malloc(sizeof(pK));

	#include <stdio.h>
	#include <time.h>

	int main( void ){
	struct tm * today = &(struct tm){
	.tm_year=123,
	.tm_mon=3,
	.tm_mday=20
	};
	mktime(today);
	auto buffer = (char [42]){};
	strftime(buffer, 42, "%A, %F", today);
	puts(buffer);
	}

	typedef struct point {
	int x;
	int y;
	} point_s;

	point_s makepoint(int x, int y) {
	point_s temp;
	temp.x = x;
	temp.y = y;
	return temp;
	}

	point_s p = makepoint(42, 24);

	struct data {
	const char* str;
	int value;
	};

	// array contains two elements
	int array[] = {42, 24};

	// numbers contains 10 elements, the first three are: 2, 3, 5
	double numbers[10] = {2, 3, 5};

	// my_data.str == "alice"
	// my_data.value = 123
	struct data my_data = {"alice", 123};

	typedef struct driver {
	const char* name;
	unsigned char data[16];
	uint16_t flags;
	uint16_t flags_ex;
	status_f status;
	} driver_s;

	typedef struct flags {
	uint16_t standard;
	uint16_t extended;
	} flags_s;

	typedef struct driver {
	const char* name;
	unsigned char data[16];
	flags_s flags;
	status_f status;
	} driver_s;

	driver_s my_serial = {
	"serial",
	.status= &status_serial,
	.flags= { 0x1234, 0x4321 }
	};

	void func(void){
	auto number = 42.24f;
	}

	void func(void){
	bool enable = false;
	}

	double numbers[42] = { [10]=55, [5]=5, [1]=1 };

	double numbers[42] = { [5]=5, [10]=55, [1]=1 };

	#define SZ (42)

	typedef struct data_s {
	char * id;
	double * values;
	} data_s;

	data_s arr[SZ] = { [SZ-1].id = "last data point" };

What	C	C++
`driver_s my_serial = { .flags = {0x4321}, .name="" };`	✔	✘nope, out of order
`driver_s my_serial = { .flags = {0x4321}, 0 };`	✔	✘nope, mixed
`driver_s my_serial = { .flags.extended = 0x4321 };`	✔	✘nope, nesting
`double numbers[] = {[10] = 55};`	✔	✘nope: no array designated initializers

	size_t a_lot = { 100 };

	int* numbers = malloc(a_lot *
	sizeof(int));

	constexpr size_t A_LOT = { 100 };

	void func(){

	int numbers[A_LOT];

	}

	static const size_t A_LOT = { 100 };

	void func(){

	int numbers[A_LOT];

	}

	void filter(size_t len){

	// ok - block scope
	double buffer[len];

	}

	size_t size = 100;

	// nope - file scope
	double oh_no[size];

	void filter(size_t len){

	double buffer[len];

	for (size_t i = 0; i < len; ++i)
	buffer[i] = arr[i];

	}

	int test_vla(size_t n){

	if (n > MY_ALLOWED_SIZE){
	fprintf(stderr, "Too big!");
	return -1;
	}

	int arr[n];

	get_data(n, arr);
	return sum(n, arr);
	}

	int test_known_size(size_t n){

	if (n > MY_ALLOWED_SIZE){
	fprintf(stderr, "Too big!");
	return -1;
	}

	int arr[MY_ALLOWED_SIZE];

	get_data(n, arr);
	return sum(n, arr);
	}

	int test_known_size(size_t n){

	int arr[10];

	get_data(n, arr);
	return sum(n, arr);
	}

	test_vla:
	push rbp
	mov rbp, rsp
	push r14
	push rbx
	mov rbx, rdi
	mov r14, rsp
	lea rax, [4*rdi + 15]
	and rax, -16
	sub r14, rax
	mov rsp, r14
	mov rsi, r14

	; get_data & sum calls

	lea rsp, [rbp - 16]
	pop rbx
	pop r14
	pop rbp
	ret

	test_known_size:
	push r14
	push rbx
	sub rsp, 40
	mov rbx, rdi
	mov r14, rsp
	mov rsi, r14

	; get_data & sum calls

	add rsp, 40
	pop rbx
	pop rbp
	ret

	int use_vla(size_t n, int numbers[n]){
	return numbers[n/2];
	}

	int main(void){
	int numbers[] = {1, 2, 3, 4, 5};
	return use_vla(5, numbers);
	}

	void make_great( int n, char buffer[n] ){

	const char * str = "C is great, long live C!";
	while (--n > 0 && *str){
	buffer++ = str++;
	}
	*buffer = '\0';

	}

	void sum( size_t n, double numbers[static n] ){

	double sum = 0;
	for(size_t i = 0; i < n; ++i ){
	sum += numbers[i];
	}
	return sum;

	}

	time_t time( time_t * arg ){
	time_t result = /* ??? */ ;

	if (arg)
	*arg = result;

	return result;
	}

	size_t strlen(const char str[static 1]){
	size_t len = 0;
	while( *str++ != '\0')
	++len;
	return len;
	}

	pair_s solve_quadratic(double coeffs[static 3]);

	double c0[] = {1, 2};
	double* c1 = malloc(sizeof(double[2]));

	pair_s r = solve_quadratic(c0);
	pair_s r = solve_quadratic(c1);

	size_t strlen(const char str[static 1]);

	const char* str = nullptr;
	size_t len = strlen(str);