C++ Member Access Operators – Access Class and Structure Members

Introduction – What Are Member Access Operators in C++?

Member access operators in C++ are used to access data members and member functions of structures, classes, and unions. These operators allow you to interact with an object’s properties whether you’re working with regular objects, pointers, or class inheritance.

In this guide, you’ll learn:

• The different member access operators
• When and how to use . and ->
• Accessing members through pointers
• Scope resolution for static and inherited members

Types of Member Access Operators in C++

Dot Operator . – Direct Access

Use this when you have an object (not a pointer):

struct Person {
    string name;
    int age;
};

Person p;
p.name = "Alice";
p.age = 25;

Arrow Operator -> – Pointer Access

Used when working with a pointer to an object:

Person* ptr = &p;
ptr->name = "Bob";
ptr->age = 30;

ptr->member is shorthand for (*ptr).member

Scope Resolution Operator ::

Used to access:

• Static members
• Global functions
• Namespaced elements
• Class-level members from outside

class Test {
public:
    static int count;
};

int Test::count = 0;  // Accessing static member

Member Access in Classes and Structs

class Rectangle {
public:
    int width, height;

    int area() {
        return width * height;
    }
};

Rectangle r;
r.width = 10;
r.height = 5;
cout << "Area: " << r.area();  // Access member function

Using Member Access with Inheritance

class Animal {
public:
    void sound() { cout << "Animal sound"; }
};

class Dog : public Animal {
public:
    void bark() { cout << "Dog bark"; }
};

Dog d;
d.sound();  // Inherited method
d.bark();

Common Mistakes

Best Practices

• Use -> only when working with valid pointers
• Use . for all stack-allocated or reference-based objects
• Prefer :: for accessing class-level or static content

Summary – Recap & Next Steps

Key Takeaways:

• . accesses members from objects or references
• -> accesses members from pointers to objects
• :: accesses static members, namespace content, and class-level scope

Real-World Relevance:
These operators are critical in object-oriented programming, dynamic memory, and encapsulation, and power abstraction in large-scale C++ applications.

FAQs – C++ Member Access Operators

What is the difference between . and -> in C++?
. is used for objects. -> is used for pointers to objects.

What does the :: operator do?
It accesses class-level, static, or namespaced members.

Can I use -> with references?
No. Use . with references. -> is for pointers only.

How do I access static variables?
Use ClassName::memberName or via object if allowed.

Is (*ptr).member the same as ptr->member?
Yes, ptr->member is shorthand for (*ptr).member.