LeetCode 刷题

const int var = 100;
int const var = 100;

// C program to demonstrate that constant variables can not be modified
int main()
{
    const int var = 100;

    // Compilation error: assignment of read-only variable 'var'
    var = 200;

    return 0;
}

const char *str = "Hello, World!";

const int* ptr;
int const *ptr;

// C program to demonstrate that the pointer to point to any other integer variable, 
// but the value of the object (entity) pointed can not be changed

int main(void)
{
    int i = 10;
    int j = 20;
    /* ptr is pointer to constant */
    const int* ptr = &i;

    printf("ptr: %d\n", *ptr);
    /* error: object pointed cannot be modified using the pointer ptr */
    /* error: assignment of read-only location '*ptr' */
    *ptr = 100;

    ptr = &j; /* valid */
    printf("ptr: %d\n", *ptr);

    return 0;
}

// C program to demonstrate that the pointer to point to any other integer variable, 
// but the value of the object (entity) pointed can not be changed

int main(void)
{
    /* i is stored in read only area*/
    int const i = 10;
    int j = 20;

    /* pointer to integer constant. Here i
    is of type "const int", and &i is of
    type "const int *". And ptr is of type
    "const int *", types are matching no issue */
    int const* ptr = &i;

    printf("ptr: %d\n", *ptr);

    /* error: assignment of read-only location '*ptr' */
    *ptr = 100;

    /* valid. We call it up qualification. In
    C/C++, the type of "int *" is allowed to up
    qualify to the type "const int *". The type of
    &j is "int *" and is implicitly up qualified by
    the compiler to "const int *" */

    ptr = &j;
    printf("ptr: %d\n", *ptr);

    return 0;
}

// C program to demonstrate the down qualification

int main(void)
{
    int i = 10;
    int const j = 20;

    /* ptr is pointing an integer object */
    int* ptr = &i;

    printf("*ptr: %d\n", *ptr);

    /* The below assignment is invalid in C++, results in
    error In C, the compiler *may* throw a warning, but
    casting is implicitly allowed */
    ptr = &j;  /* warning: assignment discards ‘const’ qualifier from pointer target type [-Wdiscarded-qualifiers] */

    /* In C++, it is called 'down qualification'. The type
    of expression &j is "const int *" and the type of ptr
    is "int *". The assignment "ptr = &j" causes to
    implicitly remove const-ness from the expression &j.
    C++ being more type restrictive, will not allow
    implicit down qualification. However, C++ allows
    implicit up qualification. The reason being, const
    qualified identifiers are bound to be placed in
    read-only memory (but not always). If C++ allows
    above kind of assignment (ptr = &j), we can use 'ptr'
    to modify value of j which is in read-only memory.
    The consequences are implementation dependent, the
    program may fail
    at runtime. So strict type checking helps clean code.
    */

    printf("*ptr: %d\n", *ptr);

    return 0;
}

int* const ptr;

// C program to demonstrate that the value of object pointed
// by pointer can be changed but the pointer can not point to another variable

int main(void)
{
    int i = 10;
    int j = 20;

    /* constant pointer to integer */
    int* const ptr = &i;
    printf("ptr: %d\n", *ptr);

    *ptr = 100; /* valid */
    printf("ptr: %d\n", *ptr);

    /* error: assignment of read-only variable 'ptr' */
    ptr = &j;

    return 0;
}

const int* const ptr;

// C program to demonstrate that value pointed by the
// pointer can not be changed as well as we cannot point the
// pointer to other variables

int main(void)
{
    int i = 10;
    int j = 20;

    /* constant pointer to constant integer */
    const int* const ptr = &i;
    printf("ptr: %d\n", *ptr);

    ptr = &j; /* error: assignment of read-only variable 'ptr' */
    *ptr = 100; /* error: assignment of read-only location '*ptr' */

    return 0;
}