Classes and objects - 5

The first thing to look at is the last two default member functions ： Access address and const Its address operator is overloaded

For members of ordinary objects, it is very simple to overload the address ：

                           

Direct implementation , And for the const We need to change the address overload of members of ordinary objects ：

        Now let's talk about const member ,const Modify the member function of a class ： take const The member function of the modified class is called const Member functions ,const Modify class member functions , In fact, it is implicit to modify the member function this The pointer , Indicates that no member of the class can be modified in the member function . for instance ：

        We add... After the parameter const when , On behalf of const Decorated all the parameters in this member function , And all parameters of the function cannot be changed （ Change will report an error ）, It is equivalent to protecting the program . Another example ：

This should be well understood .

        Be careful ： For ordinary objects , You can call ordinary member functions , You can call const Member functions ; about const object , Can only call const Member functions , Normal member functions cannot be called . also const Member functions cannot call normal member functions （ May indirectly modify ）, Ordinary member functions can call const Member functions . To use const Define member variables , Must be initialized .const The modifier is a constant , And replace it in the compilation stage .

And here comes the question , If we just want to change a parameter in a member function , Other parameters do not change , So what should we do ？？

        At this time, we will introduce keywords ：mutable, When you start defining member variables of a class , You can add... To the front of the member variable to be changed mutable, In this class const In member function , We use it mutable The defined member variables can be modified .

          

        Next, let's talk about the constructor mentioned before , We all know , When you create an object , The compiler calls the constructor , Give each member variable in the object an appropriate initial value ; however , Strictly speaking , This cannot be called initialization of class object members , It can only be called as the initial value given in the function body （ Initialization can only occur once , Assignment can be done many times ）. therefore , Next, we introduce the concept of initialization list .

Initialization list ： Start with a colon , Then a comma separated list of data members , Every “ Member variables “ Followed by the initial value or expression in parentheses , for example ：

       

Be careful ：

1. Each member variable can only appear once in the initialization list

2. Class contains the following members , Must be placed in the initialization list position to initialize ： Reference member variables ,const Member variables , Custom type member variable

3. Try to initialize with an initialization list , Because whether you call the initialization list or not , For custom member variables , Will use the initialization list first

4. The order in which member variables are declared in a class is the order in which they are initialized in the initialization list （ It is independent of its order in the initialization list ）

        Next, let's talk about a keyword ：explicit. Constructors can not only construct and initialize objects , For single argument constructors , And the role of type conversion , Let's take an example ：

        

      We actually feel strange at first , Why can an integer be assigned to a date class object ？？ Actually d1=2021 The code logic of this step is , When the compiler comes to d1=2021 when , First use 2021 Call the one parameter constructor to create a temporary object , Then use temporary objects to dd Assign a value , Last call ~Date Destroy temporary objects .（ Single argument constructors are not recommended ）, When we use explicit When decorating a constructor , Will prohibit implicit conversion of single parameter constructors .

So if there's a need now ： We need to know how many objects a class creates ？ So how do we write ？

Let's look at the code first ：

        There will be problems when we debug , It is supposed to store an object created by ourselves , however d3 Two objects are created , So ordinary member variables don't work . Because each object of the ordinary member variable has a , And linked to specific objects , The objects we need to count should not be bound with objects , It should be shared by all objects .

Next, let's use global variables to see ：

        We can see , This result is in line with what we want , It is a variable to count all the objects of class price creation . however , Although the code is very simple and can achieve the desired effect , But the code is still unsafe , Global variables can be accessed arbitrarily by members in the whole project , And if we accidentally make a mistake , It may also lead to wrong results .

So we need a shared variable , It also introduces static member

       static member , Declare as static A class member of a class is called a static member of a class , use static Modified member variables , It's called a static member variable ; use static Decorated member function , Called static member function . Static member variables are simply declared in a class , Need to be in Redefine outside the class （ No extra class static, But add the class name ::）; Static member variables are not stored in the object , Not an attribute of a specific object , It all objects Common member variables ; Static member variables can be passed through objects , Static member variable name || Class name :: Static member variable name ; Static functions are restricted by access qualifiers ; Static function variables cannot be initialized at the constructor initialization position

Let's take the above code as an example ：

                     

                 

        If we want to call static member variables outside the class, we can write a function inside the class , Returns the value of a static member variable , Then call... Externally （ Static member variable sharing , You don't have to refer specifically to an object ）

Be careful ： In static functions, there is no this Pointer , That is, we cannot call non static member variables ; however , Ordinary member functions can call static member variables and functions . Static member functions cannot be set const Member functions （ Talked about before ,const The decoration is this The pointer ）. Static member functions cannot be used as virtual functions （ The back can speak ）

Okay , Today's content is here , I hope you can understand more after you go down , Watch more , Thank you for seeing the last ！！！