cpp <chrono>- member type defenition - c++11

Question

I am learning cpp. I thought that memeber type are functions/variable which belong to a type.
For exanple in the following
class person
{
public:
string name;
int age;
};
name and age are member type (in this case member class) of the person class.
Recently I started to read about <chrono> library, and thaen I started to confused.
There is for example class system_clock which has time_point member type. But on the other hand there is also class time_point which has Clock member type (e.g class system_clock).
How can a class contains sompe type as a member type and also be a member type of its own member type.
I hope that I succeeded to explain my confusion.

Answer 1

You are confusing non-static data members with nested member type aliases.
Examples of non-static data member are name and age in:
class person
{
public:
string name;
int age;
};
name and age store values inside a specific instance of person. They have an address in an lvalue instance of person so you can find out what that address is:
person p;
string* np = &p.name; // this is where p.name lives in memory
A nested type alias does not occupy storage. For example:
class person
{
public:
using name_type = string;
string name;
int age;
};
person::name_type is a type alias for string. It doesn't occupy storage. You could use it to create a string:
person::name_type x = string{};
system_clock::time_point is a type alias for:
time_point<system_clock, system_clock::duration>
time_point::clock is a type alias for Clock in:
time_point<Clock, ...>
So, time_point<system_clock, system_clock::duration>::clock is the same type as system_clock.
system_clock does not store a time_pont. Indeed, it does not store anything at all (no non-static data members).
time_point does not have a clock as a non-static data member. time_point only stores a duration which has the type of time_point's second template parameter in:
template <class Clock, class Duration = typename Clock::duration>
class time_point;
These type aliases might be used like this:
system_clock::time_point tp = system_clock::now();
Though the use of auto here is much easier (and my preference):
auto tp = system_clock::now();
Use of time_point::clock might come in handy if you had a generic time_point and you needed to call now() for whatever clock that time_point is measured with:
template <class TimePoint>
void some_function(TimePoint tp)
{
using Clock = typename TimePoint::clock;
auto now = Clock::now();
...
This latter use-case is more rare, but the capability is there if you need it.
In general, when learning about <chrono>, most people do better by reading tutorial-like information about it, or looking at example code, or reading other's Stack Overflow questions about it. When people try to learn about <chrono> by studying its implementation, they invariably have a strong negative reaction to its relatively complex implementation.
Its implementation is relatively complex because it is far more powerful than alternatives such as timespec. However its common everyday use has very simple and safe syntax. For common use cases you don't even need to know that everything is templated. You can just use things like system_clock::now(), nanoseconds and hours.
I recommend reading some of the [chrono]-tagged questions. I also recommend reading parts of the <chrono> proposal found here:
http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2661.htm
The committee itself needed a tutorial on this subject, and this paper contains a pretty good one. Skip the parts containing proposed wording unless you're in need of a sleeping aid. The paper is somewhat dated in that a few details have changed, but not many. One example is that monotonic_clock has since been renamed to steady_clock. Another detail is that constexpr has since been generously applied. And user-defined literals have since been added to the 6 concrete duration types.
Finally, Nicolai M. Josuttis' second edition of The C++ Standard Library - A Tutorial and Reference has a nice section on <chrono>.