In pure C things are a bit different from what you describe.

Declaration has (annoyingly) multiple definitions depending on the context. The most basic one is when you are creating an instance of a variable, you are telling the compiler that you want a variable with symbol name X, data type Y, and qualifiers A,B and C. During compilation the compiler will read that and start reserving memory for the linker to assign later. These statements are always in the form of “qualifiers data_type symbol;”

Function declaration is a bit different, here you’re telling the compiler “hey you’re going to see this function show up later. Here are the types for arguments and return. I pinky swear promise you’ll get a definition somewhere else”. You can compile without the definition but the linker will get real unhappy if you don’t have the definition when it’s trying to run. Here you’re looking at a statement of “qualifiers return_data_type symbol(arg_1_data_type arg_1_symbol,…);” Technically in function declarations you don’t need argument symbols, just the types, but it’s better to just have them for readability.

Structs are different still. Here you’re telling the compiler that you’re going to have this struct definition somewhere else in the same translation unit, but the data type symbol will show up before the definition. So whenever the compiler sees that data type show up in a variable instance declaration it won’t reserve space right away but it has to have the struct definition before compilation ends. This is pretty straightforward syntax wise, “struct struct_name;” (Typedefs throw a syntax wrench into this that I won’t get into, it’s functionally the same though)

One more thing you can do with variables during declaration is to “extern” them. This is more similar to function declaration, where you’re telling the compiler “hey you’re gonna see this symbol pop up, here’s how you use it, but it actually lives somewhere else k thx bye”. I personally don’t like calling this declaration since it behaves differently than normal declaration. This is the same as a normal variable declaration syntax with “extern” tossed in the front of the qualifiers.

Definitions have two types: Function definitions contain the actual code that gets translated into instructions, Enum, struct, typedef definitions all describe memory requirements when they get used.

Structs and enums will have syntax like “struct struct_name {blah,blah,blah};”, typedefs are just “typedef new_name old_name;”, and function definition “qualifiers return_data_type symbol(arg_1_data_type arg_1_symbol,…) {Blah,blah,blah}” (note that function definitions don’t need a ; at the end and here you do need argument symbols)

Lastly, when you create a variable instance, if you say that you want that symbol to have value X all in one statement, by the standard that’s initialization. So “int foo = 5;” is declaration and initialization. Structs and arrays have special initialization syntax, “struct foo bar = {5, 6, 7};” where the numbers you write out in the list gets applied in order of the element names in the struct definition. You can also use named initialization for structs where it would look like “struct foo bar = {. element_one = 5, .e_two = 6, .e_three = 7};” This style syntax is only available for initialization, you cannot use that syntax for any other assignment. In other words you can’t change elements in bulk, you have to do it one at a time.

C lets you get real wild and combine struct definition, struct instance declaration and initialization all into one! Though if I was your code reviewer I’d reject that for readability.

<\wall-o-text>

I would define them as follows:

• Declaration: This thing exists.
• Definition: Here are the details for how this thing works.
• Initialization: Assign the initial state to this thing.
• Assignment: The value of this thing is now X.

My understanding:

int a = 1;
   // variable definition =
   // declaration + initialisation

int b; // variable declaration

b = 2  // variable initialisation,
       // type of assignment

a = 3  // variable assignment

int f(int x, int y);
   // function declaration

int g(int z) {
   return z;
}  // function definition

int f(int x, int y) {
   return x + y;
}  // function definition

Initialization is a subset of assignment. Its initialization the first time you do an assignment.

I dont think declaration and definition overlap, but they are similar concepts. I think i would have swapped your descriptions though. Normally you have a function definition, which describes the function and its features, and you have variable declarations, which is literal objects/bits of memory.

Please dont take this response as gospel, i am not super happy with it :/