[2021] Bab 8 Pointer - part 1

Summary

The lecture introduces pointers in C, focusing on what a pointer stores, how to declare one, how to make it point to another variable, and how to access that variable indirectly. The instructor emphasizes that pointers may seem difficult at first, but careful, patient practice makes them manageable.

Main Concepts

• A pointer is a variable that stores an address.

  • An ordinary variable stores a value, such as the integer 10.
  • A pointer stores the memory address where another variable is located.
  • An example address such as 1000 is illustrative; actual addresses can differ.

• Declaring a pointer

  • A declaration such as int *px; means that px is a pointer intended to point to an int.
  • The * in the declaration indicates the pointer type; it does not mean that the pointer directly stores an integer value.
  • A pointer should point to data of a compatible type.

• Getting a variable’s address

  • The & operator obtains a variable’s address.
  • For example, if x is an integer, px = &x; stores the address of x in px.
  • Once assigned, the pointer refers to the memory location containing x.

• Dereferencing a pointer

  • The * operator can also access the value at the address stored in a pointer.
  • If px points to x, then *px accesses the value of x indirectly.
  • Changing *px changes the value stored in x.
  • This is called indirect access: the program uses the pointer rather than naming the original variable directly.

• Reading pointer expressions carefully

  • Distinguish between:
    • px: the address stored in the pointer.
    • *px: the value at that address.
    • &x: the address of x.
  • Read expressions step by step—for example, “the value at the address contained in px”—to avoid confusing an address with the value stored there.

• Pointer and target types should match

  • A pointer declared for one data type should point to a variable of that same type, such as an int pointer pointing to an int.
  • Pointing to a different type can cause the program to interpret memory incorrectly. Different types may occupy different amounts of memory, so a mismatched pointer may not read the intended data.
  • The practical lesson is to use compatible pointer and variable types.

Learning Advice and Practice

• Be patient and careful. Pointers are often challenging at first, but become easier once the basic rules are understood.
• Work through pointer expressions repeatedly and practice explaining them aloud.
• When tracing code, draw a memory diagram that shows:
  • each variable and its value;
  • the illustrative address of each variable;
  • the address stored in each pointer; and
  • the value accessed by a dereference such as *px.
• Remember that example addresses are arbitrary. The important point is the relationship between a pointer and the location it refers to.

Assignment

The instructor assigns a paper-based exercise rather than a coding task:

• Complete the specified questions in the practicum module.
• For each statement, draw a memory-allocation illustration showing how the variables and pointers relate.
• Trace the statements and estimate the results of execution.
• Keep corrections readable rather than erasing work completely, and make the diagrams neat.
• The exercise relies on the pointer concepts and examples covered in the lecture.

Speakers and Sources

• Umi Sa’adah — lecturer and presenter.
• Students/class audience — present as learners, but no separate speaker is clearly identifiable in the subtitles.
• Teaching materials mentioned — lecture slides, a practicum module or worksheet, and pointer references gathered from various sources. No specific external author or publication is clearly identified.