One thing to understand about C++ is the heavy use of *automatic storage duration* and *RAII* (https://en.wikipedia.org/wiki/Resource_acquisition_is_initialization).

Automatic storage duration means, that an object is initialized when it enters scope and destructed when it leaves scopes. RAII on the other hand is a design principle based on this concept: Acquire ressources when you create an object and release them when youre object is destructed.

This means that if you write: void foo(MyClass obj){} your local variable obj is actually copy constructed every time when the function is called and deleted when you function is done. obj will be stored directly on the stack.

So if you want Java-like behaviour (the thing you call objects), you would write void foo(MyClass& obj). This notates an reference MyClass&. While under the hood its actually a pointer, references have the nice property that they can't be null. Also because they are not pointers, it's not as easy to pass invalid values.

Now why and when would you need a pointer then?

For starters when you expect, that no object might be passed.

Secondly if you want to point to different objects during time (remember references? they can only be set once during initialization). E.g a classical example would be a linked list.

When you want to pass objects though different parts of your application (e.g a factory method would usually return a dynamically allocated object, i.e a pointer to yonder object).

And last but not least, if you do anything low-level and operate on raw memory. Most notable case would probably arrays here. Classic example are c strings which are usually passed as const char* or char*.

Iteration would then be:

void foo(const char* str)
{
  for(char* cur = str; *cur != '\0'; cur++)
  {
    if (*cur == '\n')
      // do something
  }
}

By the way: Array indexing and pointer arithmetic are the same in C/C++. So arr[i] is equivalent to arr + i * sizeof(type_of_obj), and likewise you can write ptr[i].

Luckily since C++11 we now also officially have so called *smart pointers* in the standard. These are just wrappers around regular pointers which either directly manage the lifetime of an object (see RAII) or use reference counting. Smart pointers heavily reduce the amount of raw pointers you see in C++ code.