Why is it a bad idea to use scope resolution operator with a private method?

Suppose I have some class

class ClassOne {
    private:
    void methodOne();

    public:
    void methodTwo();
};

Now

void ClassOne::methodOne() { // <-- private
   // other code
}

void ClassOne::methodTwo() { // <-- public
   // other code
   ClassOne::methodOne(); // <-- private function called with scope resolution operator
}

I have been told this is something that I shouldn't do and instead to

void ClassOne::methodTwo() { // <-- public
   // other code
   methodOne();              // <-- private function 
}

Can someone explain why this is not goot practice or wrong practice?

When I compile I get no errros, so I want to understand what issue can occur.

Don't Repeat Yourself

In software development, there is a general principle called "Don't Repeat Yourself" (DRY).
It's best to avoid repeating information because:

1. If you update the information (such as the name of the class), you will have to make that change in multiple places.
2. The repeated information doesn't serve any purpose. It's just noise which makes it harder for the reader to comprehend the code, because there is more to read.

void ClassOne::methodTwo() {
   methodOne();
}

In this example, it is possible to write ClassOne::methodOne() or even ::ClassOne::methodOne(), but it would be totally pointless. This code is located in a member function of ClassOne, so we already know that methodOne() is possibly a member function.
If you want to be certain that it is a member function, there are better ways to express that.

Alternative Ways of Explicitly Referring to Members

If you want to emphasize that it is a member function, you can:

• add a prefix to your member functions, e.g. m_methodOne()
• use this when accessing members, i.e. this->methodOne()

These two methods don't repeat the class name, but still emphasize that we are using a member function, making them much better.

Sometimes, You Must Repeat the Class Name

Note that sometimes, you are left with no other choice than to repeat the class name, in order to disambiguate.
For example, if you inherit from to classes A and B which both have a member function called method(), you will have to write A::method() or B::method() to disambiguate and choose the right one.

However, situations like that are very uncommon.
Using the class name only in these cases has the added benefit that we're emphasizing them and making it obvious that something unusual is taking place.