What is a side effect in C?

Question

In C99 clause 5.1.2.3 paragraph 2,

Accessing a volatile object, modifying an object, modifying a file, or calling a function that does any of those operations are all side effects, which are changes in the state of the execution environment.

C standard defines side effects like above. But It seems C99 doesn't explain what exactly is accessing a volatile object, modifying an object, modifying a file(It's defined in the clause 3 what is the definition of access, modify, object. But accessing a volatile how? modifying what object? and modifying what of a file?).
There are some examples in C99 as I search with the word side effects. But I can't be sure whether each of examples is classified among accessing a volatile object, modifying an object and modifying a file.
I read What is side effect in c? and Are side effects a good thing? but still am confused.
My question is that does the C standard explicitly describe a meaning of side effects? What they mean?

Answer 1

My question is that does the C standard explicitly describe a meaning of side effects?

The sentence in the C standard you quote (C 1999 5.1.2.3 2, and the same in C 2018) explicitly describes the meaning of side effects. These are further explained below.

Modifying An Object

Modifying an object is understood to include the things that update the stored bytes that represent the object. I believe a complete list of them is:

• Simple assignment (=) and compound assignment (*=, /= %=, +=, -=, <<=, >>=, &=, ^=, and |=).
• The increment and decrement operators (++ and --), both prefix and postfix.
• Initialization of an object included in its definition.
• Library routines that are specified to change objects, such as memcpy.

Accessing a Volatile Object

“Access” is defined in C 2018 3.1 as “⟨execution-time action⟩ to read or modify the value of an object”. If x is a volatile int, then using the value of x in an expression accesses it (when the expression is evaluated), because it reads the value of x. You can follow this more specifically in that 6.3.2.1 2 tells us that the use of x in an expression results in the value of x being taken:

Except when it is the operand of the sizeof operator, the unary & operator, the ++ operator, the -- operator, or the left operand of the . operator or an assignment operator, an lvalue that does not have array type is converted to the value stored in the designated object (and is no longer an lvalue); this is called lvalue conversion.

So the x in the expression which is, by itself, just a designation of the object x, is converted to the value stored in x, which means that stored value is read from memory. That is an access of x.

Modifying a volatile object is the same as modifying any object, described above.

Modifying a File

Files are modified by way of the routines defined in clause 7.21 (“Input/output <stdio.h>”).

Answer 2

Accessing a volatile object means reading the value of a volatile-qualified object / an object through a volatile-qualified lvalue - the standard says these need to be evaluated "strictly according to the rules of the abstract machine".

Modifying an object means modifying any object at all - modifying anything is considered a side effect. Example: an assignment operator has a side effect of modifying a variable it assigns the value to! In the following program. An assignment operator is used for its side effect!

Modifying a file means writing to the file, creating a file, deleting a file and so forth - anything that constitutes a change.

Examples of side effects from these categories:

void increment(int *p) {
    (*p) ++; // side effect - assign a new value to the 
             // object pointed to by p
}


int a = 5;
volatile int b = 6;
if (b == 6) { // side-effect of accessing a volatile variable
    a += b;   // calculate a + b, and as a side effect assign a new 
              // value to a
}

increment(&a);     // side effect - call a function that does
                   // one of the aforementioned operations
printf("%d\n", a); // side effect - change the state of an output stream

FILE *fp = fopen("foo", "w"); // side effect - create or truncate
fputc('!', fp); // side effect - modify file
fclose(fp);.    // side effect - close the file, flush 
remove("bar");. // side effect - remove file

---

There is a (way smaller) category of programming languages called pure functional languages, such as Haskell, whose computations are side-effect free. C is not one of such languages.