：： 与 。 用于成员函数（C ++）

Question

I know that, given a class, say, std::array, which has a member function, say, size(), we can call on that member function via a ".", that is, in the following code,

array<int,5> myarray;
int s=myarray.size();

s would be the integer representing the size of myarray. The tricky thing happens when member functions can also be called by the namespace operator "::". For example, I know that the following line of code is valid:

auto t=chrono::high_resolution_clock::now();

Then, what's wrong with employing the syntax we originally used with array?

chrono::high_resolution_clock myclock;
auto t=myclock.now();

Answer 1

now() is a static member function. This means that the function itself doesn't have a hidden this pointer. Instead, it's just like a regular function - just part of the class to avoid name collisions.

(THe high_resolution_clock is a class, chrono is a namespace, in your example. Both use :: to indicate "I want something from inside {namespace, class})

Answer 2

In simple terms, :: separates names from surnames, while . separates components from sub-components. (Note that in many languages like C#, Java, D, ...) there is no such distinction)

In your fist example, myarray is a variable, whose size() method refer to that particular variable.

array<int,5> myarray_a, myarray_b;
int sa=myarray_a.size();
int sb=myarray_b.size();

Will give the sizes of myarray_a and b respectively (not of array<int,5> , even if -due to this particular case- all sizes will be 5)

In the second example, now() is a static method of the class chrono::high_resolution_clock .

It doesn't matter if you have or not a variable (and how many) of type chrono::high_resolution_clock . That function does not refer to the variable but works the same for all variables of the same type (there is conceptually just one now , no matter who you ask to).

Because of this, call now() as part of a variable, of by fully qualifying its name is the same.

Note that, the size() function of std::array is strange : the size of std::array is compile time defined, hence size() could have been static as well. But std:: designers let them as member (although constexpr , so still usable in compile time expressions) to retain the same behavior as in std::array or other containers (where it has to be dynamic, and associated to a variable, since each size can vary during execution)

Answer 3

您在这里混淆了两个概念：“ ::”用于名称空间，也用于调用静态方法。

Answer 4

There is nothing wrong with the syntax you suggested. It works.

However it creates an object, whereas the :: version does not create any object. There doesn't seem to be much point in creating that object since it is not necessary to do so in order to call the static function. So it is simpler to just call the static function without creating the object.