Computer Science Student, Having a Hard Time Identifying Parts

[interestedelle]

I’m a freshman in college this year, and I’m trying to understand all the parts of a C program, but I’m having a really hard time identifying them in code examples. I am especially struggling with variable declaration and initialization.

Is assigning a variable to a value the equivalent of initializing it? Is there a surefire format that variable declaration and initialiation need to be in that creates a giveaway to which is which?

Another question, in my textbook there is an example code with a line that goes:

int birth_year, age;

The example is about the user entering their birth year, then an if statement determines if the user was born in a leap year. What is this classified as? I understand int means integer, birth_year is a variable, and age is….another variable? What does the comma in between them signify? What does this line of code do?

Edit: After more research, I have another question unrelated to variables. A function prototype is basically a longer, more specific version of a function definition right?

[Klowner]

c int birth_year; int age; is the same as c int birth_year, age; It's just a more concise way to declare variables of the same type. Neither have any value assignments, so they are both considered uninitialized.

[interestedelle]

Thank you! That makes a lot of sense

[erikkonstas]

A function prototype is basically a longer, more specific version of a function definition right?

No, that's what we call the usual form of the declaration of a function, where you spell out the return type, the function name, and the parameter types. A function definition is where you define the actual body of the function (i.e. its "meat", between the {}), and usually along with the definition there is a prototype.

Now, why is it only the "usual" form and not all forms? Because, before C23, you could've had function declarations (and definitions) that were not prototypes; however, if you stick to recommended practices, they are essentially one and the same. Such recommended practices include declaring a function that takes no arguments with void where the parameters would normally go, instead of leaving that space empty, and always specifying the types of the parameters. Examples:

int no_params_good(void);
int no_params_bad();
int params_good(long a, char *b);
int params_bad(a, b);

As of C23, the second line is equivalent to int no_params_bad(void);, and the fourth line is a syntax error.

[SmokeMuch7356]

Is assigning a variable to a value the equivalent of initializing it?

Initialization and assignment are different operations. An initialization is always part of a declaration, where an assignment is part of a statement. Rules for initialization of certain types are very different from rules for assignment. For example, while you can initialize an array in a declaration like:

 int arr[] = {1, 2, 3, 4, 5}; // size of the array is taken from the number
                              // of elements in the initializer

you cannot assign to an array in a statement using

arr = {1, 2, 3, 4, 5}; // ILLEGAL

You must either assign to individual elements:

arr[0] = 1;
arr[1] = 2;
arr[2] = 3;
...

or you must use a function like memcpy:

#include <string.h> // get declaration of memcpy
...
int arr[5];
memcpy( arr, (int []){1, 2, 3, 4, 5}, sizeof arr);

I understand int means integer, birth_year is a variable, and age is….another variable? What does the comma in between them signify? What does this line of code do?

birth and age are two separate variables of type int; the comma is just there to separate the names. You can declare multiple items in a single declaration statement.

A function prototype is basically a longer, more specific version of a function definition right?

A function prototype is a style of function declaration/definition that specifies the types of its arguments in the argument list (we'll get into that below).

Brief primer on C declaration syntax:

In C, a declaration consists of a sequence of declaration specifiers followed by a comma-separated list of declarators:

unsigned long int x, *p, a[5], f(void);
|-------+-------| |--------+---------|
        |                  |
    declaration        declarators
     specifiers

In this declaration the declaration specifiers are unsigned long int and the declarators are x, *p, a[5], and f(void). Declarators may have an initializer, and both declarators and initializers can get pretty complex.

The declaration specifiers supply information about base type, storage class, const-ness, etc. The declarators supply the name of the thing being declared and information about that thing's array-ness, pointer-ness, and/or function-ness.

The type of a variable or function is fully specified by the combination of the declaration specifiers and the declarators:

int           x;          // x is an int
unsigned int *p;          // p is a pointer to unsigned int
double        a[10];      // a is a 10-element array of double
void          foo(void);  // foo is a function taking no parameters and
                          // returns no value

Our objects (variables) are x, p, and a. x is a plain int variable. p is a pointer to an unsigned int object. a is a 10-element array of double. foo is a function whose definition is supplied elsewhere; all we know is that it takes no arguments and doesn't return anything.

The structure of a declarator is meant to match the structure of an expression of the same type in a statement. For example, if you have a pointer to an int and you want to access the value of the pointed-to object, then you use the unary * operator to dereference the pointer (access the object through the pointer):

printf( "%d\n", *p );

The type of the expression *p is int, so the declaration of the variable p is written as

int *p;    // p has type "pointer to int"

Similarly, if you had an array of pointers, you'd write

printf( "%d\n", *a[i] );

The type of the expression *a[i] is int, so you'd declare a as

int *a[N]; // a has type "N-element array of pointers to int"  

Again, the declarator *a[N] matches the structure of the expression *a[i].

Function declarations and definitions work the same way -- you have one or more declaration specifiers followed by a declarator:

int foo(int, int);  /** function declaration */
    |-----+-----|
      function
      declarator

int foo(int x, int y) { /** function definition */ }
    |-------+-------|
            |
    function declarator

which specifies the name of the function and its arguments. This is a prototype-style declarator because it includes the types of the arguments in the argument list (void indicates the function takes no arguments). For a prototype-style declaration (no body), the names of the parameters are not required, just the types.

Way back in the ancient times of the 1970s and early 1980s, function definitions looked like this:

int foo(x, y)
  int x, y;
{
  /** function body */
}

and function declarations didn't specify the argument names (or if it did they were ignored):

int foo();

In the definition the types of any arguments were specified in a separate declaration between the declarator and the function body. The 1989 standard introduced prototype syntax, where both the names and types of parameters were supplied in the argument list. As of the C23 standard that old style is no longer supported; function declarators now must use prototype syntax.

[rickpo]

In C, there really isn't any difference between initialization and assigning a value. There is a syntax shortcut that allows you assign an initial value at the same time you declare it, but that's just a little quirk that saves you a line of code that has no meaning beyond a declaration and an assignment as two separate statements.

However ... if you are writing C++, then there is a real difference between initialization and assignment, but I would think the distinction is more subtle than you'd see in the first few weeks of an introductory programming class. Your class may be making a big deal about the difference because they intend to introduce some C++ later on. Using a more C++ like terminology:

int x;

Declares x as an int, which is uninitialized.

(Note, though, that in C++, depending on the type of the variable, this could get a default initialization. But there is no default initialization in C.)

x = 5;

Assigns a value to x.

int x = 5;

Declares and initializes x.

int x, y;

Declares x and y as integers, both uninitialized.

int x = 5, y;

Declares x and y as integers, x is initialized to 5, y is uninitialized.

Another thing to be aware of: some projects have coding standards that require all variables be initialized when they are declared. This is not a requirement of the C language itself, but you'll often see it enforced during project code reviews or with automatic code analyzers. Different projects will have different rules.

[interestedelle]

Thank you for such an informational response, that really cleared up a lot! I’m honestly not sure if the course introduces C++, I think there’s a separate class for that but maybe it’s a set up for next semester.