C++ difference of "::" and "->"

Question

I'm just curious whats the difference of :: and -> in C++?

Currently studying C++ because I want to study openGL and lots of tutorial in openGL using c++ so I'll just go with language that has many tutorials :)

In java or C# if you want to call a function or a reserved function you just use "." like for example text1.getText(); If you are to convert it to C++ would that be text1->getText()? and what to call them? Title is not appropriate. If -> is equal to "." in java then whats the use of "::"? I believe there are many questions out there like mine but I don't know what to call them so I cant have an accurate information. By the way I found this :: think while using sfml.

Here is an example

if (event.type == sf::Event::Closed)
            {
                // end the program
                running = false;
            }
            else if (event.type == sf::Event::Resized)
            {
                // adjust the viewport when the window is resized
                glViewport(0, 0, event.size.width, event.size.height);
            }

void renderingThread(sf::Window* window)
    {
        // activate the window's context
        window->setActive(true);


        // the rendering loop
        while (window->isOpen())
        {
            // draw...

            // end the current frame -- this is a rendering function 

(it requires the context to be active)
                window->display();
            }
        }

window uses -> while sf uses ::

`::` is how you get to a static function or field (which don't require an instance of an object), `->` is dereferencing a pointer to get to a function or field (and thus requires an instance, and uses the instance's specific values). Look up C++ operators — Patashu, May 27 '13 at 12:17
Use `::` to access members by class name, `.` to access by object value, `->` by object pointer. — riv, May 27 '13 at 12:19
No one's explicitly mentioned that the scope resolution operator works for non-static members as well. `auto f = std::bind(&Foo::bar, fooInstance);` — chris, May 27 '13 at 12:20
Please get yourself a [good book](http://stackoverflow.com/questions/388242/the-definitive-c-book-guide-and-list). — molbdnilo, May 27 '13 at 13:44

Niels Keurentjes · Accepted Answer · 2013-05-27T12:30:27.270

11

:: is the scope resolution operator, used for referencing static class members and namespace elements.

-> is the indirect reference operator, used for referencing members methods and fields on an instance pointer.

. is the direct reference operator, used for referencing member methods and fields on an instance.

Since Java has no real pointers, it has no use for the indirect reference operator.

edited May 27 '13 at 12:30

answered May 27 '13 at 12:18

Niels Keurentjes

41,402
9
98
136

3

Java has pointers, but it doesn't provide the programmer with faculties for pointer manipulations - Java handles it all for you. – Patashu May 27 '13 at 12:20
2

Technically they're more like references, but I added a 'real' before pointers in the answer for you ;) – Niels Keurentjes May 27 '13 at 12:30
Also note that static class members can be accessed from an instance, using the dot operator. – Justin Time - Reinstate Monica Jan 28 '17 at 18:25

score 4 · Answer 2 · answered May 27 '13 at 12:18

The operator -> is used when you have a pointer to an object and dereference the pointer, i.e.

string* str = new string("Hello, World");
const char* cstr = str->c_str();

whereas

string str("Hello World");
const char* cstr = str.c_str();

is used to directly reference a member.

The :: is the "scope-operator". You can use it to call static members of a class or reference a member in a namespace.

namespace X{
 int a;
}

int main() {
...
X::a = 4;
...
}

See Wikipedia on this.

C++ difference of "::" and "->"

2 Answers2