designated-initializer

Having come across problems when sub-classing UIKit classes and adding immutable variables to them, I made a test project to figure out what was going on. My conclusion is that if: we have an Objective C class, which inherits from another class, with its own designated initialiser (implicit or explicitly annotated) in its initialiser , it calls [self initWithXX] where initWithXX is an init method on the superclass we subclass this class in Swift , adding an immutable property (which obviously must be initialised on instantiation) we implement a single designated initialiser for this Swift

I have already stated confusion about CTAD with designated initializers in this question , but i have another confusion with a very similar code snippet template <typename int_t=int, typename float_t=float> struct my_pair { int_t first; float_t second; }; template<typename ... ts> my_pair(ts...) -> my_pair<ts...>; int main() { my_pair x{.second = 20.f}; static_assert( std::is_same_v<decltype(x.first), int> ); //FAILS <- its deduced to float static_assert( std::is_same_v<decltype(x.second), float> ); } It seems like the deduction guide causes the type of first to be deduced to float , even

I came across the following maze definition code: typedef struct mazeNode { int hasCheese; int tag; struct mazeNode *left; struct mazeNode *right; } maze_t; maze_t maze = { .tag = 1, .left = &(maze_t) { .left = &(maze_t) { .left = &(maze_t) {}, .right = &(maze_t) {} }, .right = &(maze_t) { .right = &(maze_t) {} } }, .right = &(maze_t) { .tag = 8, .left = &(maze_t) {}, .right = &(maze_t) { .tag = 10, .left = &(maze_t) { .tag = 11, .left = &(maze_t) { .hasCheese = 1, .tag = 12 } }, .right = &(maze_t) {} } } }; From the linked blog post I understand that they are trying to define the binary tree

I am reading a book which has a guideline: "If a class declares a designated initializer that is different from its superclass, the superclass’s designated initializer must be overridden to call the new designated initializer" As I understand this guideline in other words is that, if I am subclassing my class form its superclass, and my subclass has a designated initializer which is different from des. initializer of its superclass, then in my subclass I must override the designated initializer of my superclass and inside it call the designated initializer of my subclass. Is this true? Do we

One can use designated initializers as shown below (for "billy") without issue, but when the same initialization approach is used on dynamic memory things will break at compile-time. What are the restrictions for using designated initializers? Aside from where (i.e. the address) to which we are writing, what makes these two initializations different? Why can we not use designated initializers with dynamic memory? struct student{ char *name; int age; }; void print_student(struct student* st){ printf("Student: %s is %d years old\n", st->name, st->age); } int main(void) { srand(time(NULL));

I am aware that in C99 you can initialize members of the structure using member name as follows : struct myStruct { int i; char c; float f; }; So following is valid : struct myStruct m = {.f = 10.11, .i = 5, .c = 'a'}; Also it is said that uninitialised members will be set to 0 . So struct myStruct m = {.f = 10.11, .c = 'a'}; here i will be set to 0 But, for the following : struct myStruct m = {.f = 10.11, .c = 'a', 6}; i is still initialized to 0. What is the reason if we do such compound initialization. This is covered in the draft C99 standard section 6.7.8 Initialization , basically if the