类

--隐含的this指针

引言：

    在前面提到过，成员函数具有一个附加的隐含形参，即指向该类对象的一个指针。这个隐含形参命名为this，与调用成员函数的对象绑定在一起。成员函数不能定义this形参，而是有编译器隐含地定义。成员函数可以显式的使用this指针，但不是必须这么做。

1、何时使用this指针

    有一种情况下，我们必须显式使用this指针：当需要将一个对象作为整体引用而不是引用对象的一个成员时。

    比如在类Screen中定义两个操作：set和move，可以使得用户将这些操作的序列连接成一个单独的表达式：

    myScreen.move(4,0).set(‘#‘);
    //其等价于
    myScreen.move(4.0);
    myScreen.set(‘#‘);

2、返回*this

    在单个表达式中调用move和 set操作时,每个操作必须返回一个引用,该引用指向执行操作的那个对象:

class Screen
{
public:
    Screen &move(index r,index c);
    Screen &set(char);
    Screen &set(index,index,char);
};

这样，每个函数都会返回调用自己的那个对象。使用this指针可以用来访问该对象：

Screen &Screen::set(char c)
{
    contents[cursor] = c;
    return *this;
}

Screen &Screen::move(index r,index c)
{
    index row = r * width;
    cursor = row + c;
    return *this;
}

3、从const成员返回*this

    在普通的非const成员函数中,this的类型是一个指向类类型的const指针。可以改变this所指向的值,但不能改变this所保存的地址。在const成员函数中,this的类型是一个指向const类类型对象的const指针。既不能改变this所指向的对象,也不能改变this所保存的地址。

    不能从const成员函数返回指向类对象的普通引用。const成 员函数只能返回*this作为一个 const引用。

    我们可以给Screen类增加一个const成员函数：display操作。如果将display作为 Screen的 const成员,则 display内部的 this指针将是一个constScreen* 型的const。然而：

    myScreen.move(4,0).set(‘#‘).display(cout);	//OK
    myScreen.display().set(‘*‘);	//Error

问题在于这个表达式是在由display返回的对象上运行set。该对象是const,因为display将其对象作为const返回。我们不能在const对象上调用set。

4、基于const的重载

    为了解决以上问题，我们必须定义两个display操作：一个是const，一个不是const。基于成员函数是否为const，可以重载一个成员函数;同样的，基于一个指针形参是否指向const，也可以重载一个函数。非const对象可以使用任一成员,但非const版本是一个更好的匹配。

class Screen
{
public:
    //As before

    Screen &display(std::ostream &os)
    {
        do_display(os);
        return *this;
    }
    const Screen &display(std::ostream &os) const
    {
        do_display(os);
        return *this;
    }

private:
    void do_display(std::ostream &os) const
    {
        os << contents;
    }
    //As before
};

调用：

    Screen myScreen(5,3);
    const Screen blank(5,3);
    myScreen.set(‘#‘).display(cout);    //调用非const版本
    blank.display(cout);                //调用const版本

5、可变数据成员

    有时，我们希望类的数据成员（甚至是在const成员函数中）可以修改。这可以通过将它们声明为mutable来实现。

    可变数据成员永远都不能为const，甚至当它们是const对象的成员时也如此。因此，const成员函数可以改变mutable成员。

class Screen
{
public:
    //...

private:
    mutable size_t access_ctr;

    //使用access_ctr来跟踪Screen成员函数的调用频度
    void do_display(std::ostream &os) const
    {
        ++ access_ctr;      //OK
        os << contents;
    }
};

【建议：用于公共代码的私有实用函数】

   使用私有实用函数（如前面的do_display）的好处：

    1）一般愿望是避免在多个地方编写同样的代码。

    2）display操作预期会随着类的演变而变得复杂。当涉及到的动作变得更复杂时，只在一处而不是两处编写这些动作有更显著的意义。

    3）很可能我们会希望在开发时给do_display增加调试信息,这些调试信息将会在代码的最终成品版本中去掉。如果只需要改变一个do_display的定义来增加或删除调试代码,这样做将更容易。 4）这个额外的函数调用不需要涉及任何开销。我们使do_display成为内联的,所以调用do_display与将代码直接放入display操作的运行时性能应该是相同的。

P379习题12.13

//1. in screen.h
#ifndef SCREEN_H_INCLUDED
#define SCREEN_H_INCLUDED
#include <string>

class Screen
{
public:
    typedef std::string::size_type index;

    Screen &move(index r,index c);
    Screen &set(char);
    Screen &set(index,index,char);

    char get() const
    {
        return contents[cursor];
    }
    char get(index ht,index wd) const;

    index get_cursor() const;

    Screen &display(std::ostream &os)
    {
        do_display(os);
        return *this;
    }
    const Screen &display(std::ostream &os) const
    {
        do_display(os);
        return *this;
    }

    Screen():cursor(0),height(0),width(0){}
    Screen(index,index,const std::string &tmp);

private:
    void do_display(std::ostream &os) const
    {
        os << contents;
    }

    std::string contents;
    index cursor;
    index height,width;
};

inline char Screen::get(index ht,index wd) const
{
    index row = width * ht;
    return contents[row + wd];
}

inline Screen::index Screen::get_cursor() const
{
    return cursor;
}
#endif // SCREEN_H_INCLUDED

//2. in screen.cpp
#include "screen.h"

Screen::Screen(index ht,index wd,const std::string &cntnts):height(ht),width(wd),cursor(0),contents(cntnts){}

Screen &Screen::set(char c)
{
    contents[cursor] = c;
    return *this;
}
Screen &Screen::set(index ht,index wd,char c)
{
    index row = ht * width;
    contents[row + wd] = c;
    return *this;
}

Screen &Screen::move(index r,index c)
{
    index row = r * width;
    cursor = row + c;
    return *this;
}

//3. in main.cpp
#include <iostream>
#include "screen.h"
using namespace std;

int main()
{
    Screen myScreen(5,6,"aaaaa\naaaaa\naaaaa\naaaaa\naaaaa\naaaaa\n");
    myScreen.move(4,0).set(‘#‘).display(cout);
}