C - 如何保护变量在函数中的某个点之后不会被意外更改

Question

C - how to protect a variable from being accidentally changed after a certain point:

For example, in a C program, I declared an integer and changed it's value several times in the first part of the program. But then after a certain point I want to keep its value from being accidentally changed, or at least get a warning when any attempt to change its value happens. How do I do that?

Answer 1

You can't.

A possible solution would be to move the part of the function that modifies the variable into a separate function. That function would return the value of the variable which can be used to initialize a const variable:

int determine_value_of_a()
{
    int result = 0;
    /* Modifications of result. */
    return result;
}

void f()
{
    const int a = determine_value_of_a();
}

Answer 2

If using preprocessor macros is acceptable, then you can do this:

{ // Function body starts here.
    int x = …;
    … // Change x as desired here.
    const int y = x;
    #define x y;
    … // “x” is actually the const y here.
    #undef x
}

Generally, though, I would not recommend it. If you cannot trust the body of a single function to do things correctly, then the function is too complicated and ought to be restructured, as by calling another function to provide the value of the object.

Answer 3

Put the variable in a opaque struct with an indication of whether it can be changed. Access the variable, both for getting and changing the value, from a function. If the indication for changeability if off, the function does not allow changes

#include "swinger.h"

int main(void) {
    struct moodswinger *var;

    var = newswinger();
    setvar(var, 42);
    getvar(var);
    swing(var, 0);
    setvar(var, -1); /* oops */
}

The file swinger.h declares the functions.
The file swinger.c defines the struct and code.

Answer 4

int x;
x = …; // This is okay.
{
    const int y = x; // Make a copy of x.
    {
        const int x = y; // Make a const copy of x that hides the original.
        /*  The compiler should produce a diagnostic if you
            attempt to modify x here.
        */
    }
}

Or, if you do not want the indenting to change:

int x;
x = …;
{ const int y = x; { const int x = y;
…; // x is const here.
} }

Answer 5

The only way you could do that would be

(a) to use a function to initialize the variable..

int main( int argc, char** argv )
{
    const int myVar = initMyVar();

    ...
}

or (b) pass the variable into another function that does the other work...

void myWorkerFunc( const int myVar )
{
    ...
}

int main( int argc, char** argv )
{
    int myVar = initMyVar();

    ...

    myWorkerFunc( myVar );
}

Answer 6

Set a conditional breakpoint on it in your debugger. Then you will know if it ever changes. You could also write a "watchdog" type thread that scans your var every so often and warns on change, but that won't be immediate.

Neither of these are within the realm of C directly, but would help you determine if your var was erroneously changed.