Constant Pointer vs Pointer to Constant in C: Reading const Declarations Right

0s7 min★ 30 XP

Lesson 57Mixed lesson

Constant Pointer vs Pointer to Constant in C: Reading const Declarations Right

A structured lesson workspace with readable content, hands-on examples, and a clean path to completion.

Lesson format13 sections1 video4 code blocks1 practice itemUpdated Aug 27, 2026

const int *p and int * const p are different declarations with different meanings. The first is a pointer to a constant int: you can change where p points, but you cannot modify the int through p. The second is a constant pointer to int: p always points to the same address, but you can modify the int it points to. The position of const relative to the * determines what is constant. Reading these declarations correctly is a basic literacy skill in C.

Constant Pointer VS. Pointer To A Constant

#The Four Combinations#link

#include <stdio.h>

int main(void) {
    int x = 10;
    int y = 20;

    const int *ptr_to_const = &x;
    printf("ptr_to_const -> %d\n", *ptr_to_const);
    ptr_to_const = &y;
    printf("ptr_to_const -> %d (repointed OK)\n", *ptr_to_const);

    int *const const_ptr = &x;
    printf("const_ptr -> %d\n", *const_ptr);
    *const_ptr = 99;
    printf("const_ptr -> %d (modified OK)\n", *const_ptr);

    const int *const both_const = &x;
    printf("both_const -> %d\n", *both_const);

    return 0;
}

Run const_pointer_demo

root@vulnarex:~#gcc -Wall const_pointer_demo.c -o const_pointer_demo && ./const_pointer_demo

#The Reading Rule#link

Read C declarations right-to-left from the identifier. const int *p: start at p, go right (nothing), go left (*: pointer to), go right again (nothing), go left (const int: constant int). Result: p is a pointer to a constant int. int *const p: start at p, go right (nothing), go left (const: constant), go right (*: pointer to), go left (int). Result: p is a constant pointer to int. The const binds to whatever is immediately to its left, unless it is at the far left, in which case it binds to the right.

#What the Compiler Rejects#link

#include <stdio.h>

int main(void) {
    int x = 10;
    int y = 20;

    const int *ptr_to_const = &x;
    *ptr_to_const = 99;

    int *const const_ptr = &x;
    const_ptr = &y;

    return 0;
}

Compile const_violations (expect errors)

root@vulnarex:~#gcc -Wall const_violations.c -o const_violations

Two errors. The first: you cannot write through a pointer-to-const. The second: you cannot reassign a const pointer. The compiler enforces both. These are not warnings. They are hard errors. The const qualifier is a contract, and the compiler is the enforcer.

★ 30 XP

quiz BLOCK (★ 30 XP)

In the declaration const char *p, what is constant?

Select your proof vectors above

This distinction appears in every C API. strlen takes const char * because it does not modify the string. strcpy takes char * for the destination because it does. Reading the const placement tells you the function's contract without reading the documentation. Next: array vs &array, a subtle pointer difference that matters in multi-dimensional contexts.

Lesson completion

Ready to resolve this lesson?

Finish the lesson once you have worked through the material. This awards ★ 30 XP.

Previous lesson

Lesson tools

Workspace

0% read

Lab notes

Notes persist per lesson.

The Four Combinations The Reading Rule What the Compiler Rejects

Content

Last updated

August 27, 2026

Agent Setup

Access lesson content programmatically for AI agents, LLMs, and automated pipelines.

Fetch as Markdown (Accept header)

curl -H "Accept: text/markdown" "https://vulnarex.com/api/content/lessons?courseSlug=c-programming-tutorials&lessonSlug=57-constant-pointer-vs-pointer-to-constant&lang=en&format=markdown"

MCP Server Config (mcp.json)

{
  "mcpServers": {
    "vulnarex": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-fetch"],
      "env": { "MCP_FETCH_URL": "https://vulnarex.com" }
    }
  }
}

MCP Server Card/.well-known/mcp.json A2A Agent Card/.well-known/agent-card.json API Catalog/.well-known/api-catalog robots.txt/robots.txt

Laboratory sanity code

Isolate active probes on matched virtual networks and keep execution streams sandboxed.

#include <stdio.h>

int main(void) {

int x = 10;

int y = 20;

const int *ptr_to_const = &x;

printf("ptr_to_const -> %d\n", *ptr_to_const);

ptr_to_const = &y;

printf("ptr_to_const -> %d (repointed OK)\n", *ptr_to_const);

int *const const_ptr = &x;

printf("const_ptr -> %d\n", *const_ptr);

*const_ptr = 99;

printf("const_ptr -> %d (modified OK)\n", *const_ptr);

const int *const both_const = &x;

printf("both_const -> %d\n", *both_const);

return 0;

}