Passing pointers between objects in c++

I want to ask about passing pointers between functions or between objects or returning them .. I heard that passing or returning pointers in general (whether they point to an array or an object or whatever they are pointing at) isn't safe and the output isn't guaranteed.

Where did you get that from? In general, it's not true and of course you can pass around pointers.

The tricky thing is managing ownership of (heap-allocated) objects, since somewhere you have to release the memory again. In other words: When you allocate memory with new, you will have to free it again with delete.

Example:

A* function1(A* a) {
    return a;
}

B* function2(B* b) {
    return new B(b);
}

function1 returns an existing pointer. Whoever owned the A object passed in will also own the returned one, as it is the same. This needs to be documented since this knowledge is essential for using function1!

function2 creates a new object of class B by coping its input argument. Whoever calls function2 will own the returned object and will be responsible to delete it when it's done. Again, this needs to be documented!

also, I read in a tutorial that everything in c++ is pass by value? isn't passing pointers is called pass by reference?

Technically, passing pointers is pass-by-value since the pointer itself gets copied. But since a pointer is a "reference type", you essentially get pass-by-reference with that.

Note that C++ also knows references (int&), which really is pass-by-reference.

Well, the honest answer is that people sometimes mean different things when they say "pass by reference".

But generally, when people say "pass by reference", they mean this:

void readInt(int &a) {
    cin >> a;
}

int a;
readInt(a);
cout << a;

And "pass by pointer" would be this:

void readInt(int *a) {
    cin >> *a;
}

int a;
readInt(&a);
cout << a;

Ultimately, you can use pointers for everything that references are used for (they other way around is mostly true).

Some people like references because they can use the . operator, like they normally do. Others prefer pointers because they are explicit.

Note that pointers are older than references (C does not have references), so C libraries will use pointers exclusively.

Most people (I think) use references when they can (like in your hypothetical example). The nice thing is that type safety will stop you if you confuse references and pointers.