Android Binder 之不懂：C++ 构造函数后加冒号

今天分析android底层源码，大部分用C/C++写的，感觉好久没看C/C++了，很多都生疏了，看到好多不懂的还得重新百度。

在分析Android Binder时遇到一个类ProcessState.cpp，

1、其头文件为：/framework/base/include/binder/

<!-- lang: cpp -->
#ifndef ANDROID_PROCESS_STATE_H
#define ANDROID_PROCESS_STATE_H

#include <binder/IBinder.h>
#include <utils/KeyedVector.h>
#include <utils/String8.h>
#include <utils/String16.h>

#include <utils/threads.h>

// ---------------------------------------------------------------------------
namespace android {

// Global variables
extern int                 mArgC;
extern const char* const*  mArgV;
extern int                 mArgLen;

class IPCThreadState;

class ProcessState : public virtual RefBase
{
public:
    static  sp<ProcessState>    self();

            void                setContextObject(const sp<IBinder>& object);
            sp<IBinder>         getContextObject(const sp<IBinder>& caller);

            void                setContextObject(const sp<IBinder>& object,
                                                 const String16& name);
            sp<IBinder>         getContextObject(const String16& name,
                                                 const sp<IBinder>& caller);

            void                startThreadPool();

    typedef bool (*context_check_func)(const String16& name,
                                       const sp<IBinder>& caller,
                                       void* userData);

            bool                isContextManager(void) const;
            bool                becomeContextManager(
                                    context_check_func checkFunc,
                                    void* userData);

            sp<IBinder>         getStrongProxyForHandle(int32_t handle);
            wp<IBinder>         getWeakProxyForHandle(int32_t handle);
            void                expungeHandle(int32_t handle, IBinder* binder);

            void                setArgs(int argc, const char* const argv[]);
            int                 getArgC() const;
            const char* const*  getArgV() const;

            void                setArgV0(const char* txt);

            void                spawnPooledThread(bool isMain);

private:
    friend class IPCThreadState;

                                ProcessState();
                                ~ProcessState();

                                ProcessState(const ProcessState& o);
            ProcessState&       operator=(const ProcessState& o);

            struct handle_entry {
                IBinder* binder;
                RefBase::weakref_type* refs;
            };

            handle_entry*       lookupHandleLocked(int32_t handle);

            int                 mDriverFD;
            void*               mVMStart;

    mutable Mutex               mLock;  // protects everything below.

            Vector<handle_entry>mHandleToObject;

            bool                mManagesContexts;
            context_check_func  mBinderContextCheckFunc;
            void*               mBinderContextUserData;

            KeyedVector<String16, sp<IBinder> >
                                mContexts;


            String8             mRootDir;
            bool                mThreadPoolStarted;
    volatile int32_t            mThreadPoolSeq;
};

}; // namespace android

// ---------------------------------------------------------------------------

#endif // ANDROID_PROCESS_STATE_H

2、ProcessState.cpp：/framework/base/libs/binder/ 其构造函数为

<!-- lang: cpp -->
ProcessState::ProcessState()
    : mDriverFD(open_driver())
    , mVMStart(MAP_FAILED)
    , mManagesContexts(false)
    , mBinderContextCheckFunc(NULL)
    , mBinderContextUserData(NULL)
    , mThreadPoolStarted(false)
    , mThreadPoolSeq(1)
{
    if (mDriverFD >= 0) {
        // XXX Ideally, there should be a specific define for whether we
        // have mmap (or whether we could possibly have the kernel module
        // availabla).
#if !defined(HAVE_WIN32_IPC)
        // mmap the binder, providing a chunk of virtual address space to receive transactions.
        mVMStart = mmap(0, BINDER_VM_SIZE, PROT_READ, MAP_PRIVATE | MAP_NORESERVE, mDriverFD, 0);
        if (mVMStart == MAP_FAILED) {
            // *sigh*
            LOGE("Using /dev/binder failed: unable to mmap transaction memory.\n");
            close(mDriverFD);
            mDriverFD = -1;
        }
#else
        mDriverFD = -1;
#endif
    }

    LOG_ALWAYS_FATAL_IF(mDriverFD < 0, "Binder driver could not be opened.  Terminating.");
}

上面这段就有点看不懂了，幸好百度到一篇不错的文章有介绍： http://ivan4126.blog.163.com/blog/static/209491092201301534928785/

其实冒号后的内容是初始化成员列表，一般有三种情况：

1、对含有对象成员的对象进行初始化，例如，类line有两个私有对象成员startpoint、endpoint,line的构造函数写成：

<!-- lang: cpp -->
line（int sx,int sy,int ex,int ey）：startpoint（sx,sy），endpoint（ex,ey）{……}

初始化时按照类定义中对象成员的顺序分别调用各自对象的构造函数，再执行自己的构造函数

2、对于不含对象成员的对象，初始化时也可以套用上面的格式，例如，类rectangle有两个数据成员length、width,其构造函数写成：

<!-- lang: cpp -->
rectangle（）：length（1），width（2）{}
rectangle（int x,int y）：length（x），width（y）{}

3、对父类进行初始化，例如，

<!-- lang: cpp -->

<!-- lang: cpp -->
CDlgCalcDlg（CWnd* pParent ）： CDialog（CDlgCalcDlg::IDD, pParent）

其中IDD是一个枚举元素，标志对话框模板的ID，使用初始化成员列表对对象进行初始化，有时是必须的，有时是出于提高效率的考虑

所以上面那个构造函数的意思就是对其数据成员或者对象成员进行初始化！要理解初始化的顺序哦！