C++开发中的小习惯--访问器的使用。

  在程序开发中，有时候很想访问一个类里面所包含的容器对象。可是将容器获取出来访问，可能会让程序阅读性降低或引入一些线程间互斥的问题。举例如下：

class B
{
public:
B(){}
~B(){}
};

class A
{
public:
A(){}
~A(){}

//为了访问列表B而增加接口
const std::list<B>& listB() const {return mListB;}
std::list<B>& listB() {return mListB;}

void lockB() {mLockB.lock();}
void unlockB() {mLockB.unlock();}
protected:
std::list<B> mListB;
ThreadMutex mLockB;//B容器的锁
};

//这样会引入线程的问题,在外部访问时，就需要这样做
A a;
a.lockB();
std::list<B>& rLstB = a.listB();
for(std::list<B>::iterator it = rLstB.begin(); it != rLstB.end(); ++it)
{
    B& rb = (*it);
    //...TODO:其他操作
}
a.unlockB();

从上面例子可以看到，在外部访问a对象的容器B时，需要加锁和解锁操作。如果操作很长，在中途有return跳出函数，那么也必须加上解锁操作。非常麻烦。

我们来思考一下有没有其他较好的方法呢？就个人而言，写程序放首位的应该是阅读性。这种情况，希望封装性好，有两种方式可以实现，一是迭代器，二是访问器。首先来说一下迭代器，我摘录一段代码:

/*Iterator迭代器抽象类*/
    abstract class Iterator
    {
        public abstract object First();
        public abstract object Next();
        public abstract object CurrentItem();
        public abstract bool IsDone();
    }
    /*Aggregate聚集抽象类*/
    abstract class Aggregate
    {
        public abstract Iterator createIterator();
    }

    class ConcreteIterator : Iterator
    {

        // 定义了一个具体聚集对象
        private ConcreteAggregate aggregate;

        private int current = 0;

        // 初始化对象将具体聚集类传入
        public ConcreteIterator(ConcreteAggregate aggregate)
        {
            this.aggregate = aggregate;
        }

        // 第一个对象
        public override object First()
        {
            return aggregate[0];
        }

        // 得到聚集的下一对象
        public override object Next()
        {
            object ret = null;
            current++;
            if (current < aggregate.Count)
            {
                ret = aggregate[current];
            }
            return ret;
        }

        // 是否到结尾
        public override bool IsDone()
        {
            return current >= aggregate.Count ? true : false;
        }

        // 返回当前聚集对象
        public override object CurrentItem()
        {
            return aggregate[current];
        }

我在网络上找了一段迭代器的代码，只取了其中一段，但是可以注意到Next()函数中，ret = aggregate[current]; 通过索引来访问容器的成员，这就变相规定了，支持的容器仅仅是vector而已，对于list，map等容器，访问这个下标就太耗时间了。所以，迭代器仅仅在自己封装的链表中有效，可以直接访问节点指针。而使用标准容器时，这样用效率太低。

个人推荐使用访问器来访问容器的成员，先上代码：

class B
{
public:
B(){}
~B(){}
};

class A
{
public:
//访问器类
class BVisitor()
{
    public:
    virtual ~A(){}
    virtual void apply(const B& rb){}
};

public:
A(){}
~A(){}

void travel(BVisitor& rVisitor)
{
    mLockB.lock();
    for(std::list<B>::iterator it = mListB.begin(); it != mListB.end(); ++it)
    {
        B& rB = (*it);
        rVisitor.apply(rB);
    }
    mLockB.unlock();
}

protected:
std::list<B> mListB;
ThreadMutex mLockB;//B容器的锁
};

//外部访问时
class MyVisitor : public A::BVisitor
{
public:
    MyVisitor(C* pC, int nMode) : mC(pC), mMode(nMode){}

    void apply(const B& rb)
    {
        //仅说明用法
        if(mMode == 2)
        {
            mC->doSth(rb);
        }
        else
        {
            mC->doSth2(rb);
        }
    }
protected:
    C* mC;    //仅说明一下，可以传入一些临时变量
    int mMode;
};

//外部调用时，这样使用
void XXX()
{
    ...
    A a;
    ...
    MyVisirtor mv(&c, 2);
    a.travel(&mv);
}

这样写的好处就是封装性好，很多临时变量也可以方便传递到访问器中，代码也方便阅读。尤其在大工程中，封装性尤为重要。当然仁者见仁，也许还有其他更好的方法，这里就提出一下我自己的观点，大家一起交流共同进步。