MFC的运行机制和消息响应机制

MFC的类层次结构与运行机制

MFC的类层次结构

如图所示（子类指向父类）：

其中：

CObject：是MFC提供的绝大多数类的基类。该类完成动态空间的分配与回收，支持一般的诊断、出错信息处理和文档序列化等。

CCmdTarget：主要负责将系统事件（消息）和窗口事件（消息）发送给响应这些事件的对象，完成消息发送、等待和派遣调度等工作，实现应用程序的对象之间的协调运行。

CWinApp：是应用程序的主线程类，它是从CWinThread类派生而来的。CWinThread类用来完成对线程的控制，包括线程的创建、运行、终止和挂起等。

CDocument：是文档类，包含了应用程序在运行期间所用到的数据。

CWnd：是一个通用的窗口类，用来提供Windows中的所有通用特性、对话框和控件。

CFrameWnd是从CWnd类继承来的，并实现了标准的框架应用程序。

CDialog类用来控制对话框窗口。

CView：用于让用户通过窗口来访问文档。

CMDIFrameWnd和CMDIChildWnd：分别用于多文档应用程序的主框架窗口和文档子窗口的显示和管理。CMiniFrameWnd类是一种简化的框架窗口，它没有最大化和最小化窗口按钮，也没有窗口系统菜单，一般很少用到它。

MFC运行机制

在程序中，当定义一个类对象时，它会自动调用相应的构造函数。所谓"类对象"，就是用该类定义的"变量"，这个"变量"又称为类的一个实例。例如，theApp就是类CSimpApp的一个对象。

MFC正是利用类的这种"自动调用相应的构造函数"特性，使得WinMain()函数的调用变成了应用程序框架内部的调用，所以我们在代码中看不到每个Windows程序所必须有的WinMain()函数。

当应用程序运行到"CSimpApp theApp;"时，系统就会先调用基类CWinApp构造函数，进行一系列的内部初始化操作，然后自动调用CSimpApp的虚函数InitInstance()，该函数会进一步调用相应的函数来完成主窗口的构造和显示工作。下面来看看上述程序中InitInstance的执行过程。

首先执行的是：

m_pMainWnd = new CMainFrame;

该语句用来创建从CFrameWnd类派生而来的用户框架窗口CMainFrame类对象，继而调用该类的构造函数，使得Create函数被调用，完成了窗口创建工作。

然后执行后面两句：

m_pMainWnd->ShowWindow(m_nCmdShow);

m_pMainWnd->UpdateWindow();

用作窗口的显示和更新。接下来调用：

m_pMainWnd->MessageBox("你好，欢迎进入MFC世界！");

最后返回TRUE，表示窗口创建成功。

由于应用程序类CWinApp是用来调用WinMain以及实例的初始化，因此每一个MFC应用程序有且只能一个这样的应用程序类，且需要一个全局的对象实例，如上述程序中的theApp，当然也可换一个对象名。InitInstance()完成初始化工作之后，接下来就是调用基类CWinApp的成员函数Run()，执行应用程序的消息循环，即重复执行接收消息并转发消息的工作。当Run()检查到消息队列为空时，将调用基类CWinApp 的成员函数OnIdle进行空闲时的后台处理工作。若消息队列为空且又没有后台工作要处理时，则应用程序一直处于等待状态，一直等到有消息为止。

当程序结束后，调用基类CWinApp的成员函数ExitInstance()，完成终止应用程序的收尾工作。这就是MFC应用程序的运行机制。

MFC消息响应机制分析

---- MFC是Windows下程序设计的最流行的一个类库，但是该类库比较庞杂，尤其是它的消息映射机制，更是涉及到很多低层的东西，我们在这里，对它的整个消息映射机制进行了系统的分析，可以帮助程序开发人员对MFC的消息映射机制有一个比较透彻的了解。

1．引言

---- VC++的MFC类库实际上是Windows下C++编程的一套最为流行的类库。MFC的框架结构大大方便了程序员的编程工作，但是为了更加有效、灵活的使用MFC编程，了解MFC的体系结构往往可以使编程工作事半功倍。它合理的封装了WIN32 API函数，并设计了一套方便的消息映射机制。但这套机制本身比较庞大和复杂，对它的分析和了解无疑有助于我们写出更为合理的高效的程序。这里我们简单的分析MFC的消息响应机制，以了解MFC是如何对Windows的消息加以封装，方便用户的开发。

2. SDK下的消息机制实现

---- 这里简单的回顾一下SDK下我们是如何进行Windows的程序开发的。一般来说，Windows的消息都是和线程相对应的。即Windows会把消息发送给和该消息相对应的线程。在SDK的模式下，程序是通过GetMessage函数从和某个线程相对应的消息队列里面把消息取出来并放到一个特殊的结构里面，一个消息的结构是一个如下的STRUCTURE。

typedef struct tagMSG {

HWND hwnd;

UINT message;

WPARAM wParam;

LPARAM lParam;

DWORD time;

POINT pt;

}MSG;

---- 其中hwnd表示和窗口过程相关的窗口的句柄，message表示消息的ID号，wParam和lParam表示和消息相关的参数，time表示消息发送的时间，pt表示消息发送时的鼠标的位置。

---- 然后TranslateMessage函数用来把虚键消息翻译成字符消息并放到响应的消息队列里面，最后DispatchMessage函数把消息分发到相关的窗口过程。然后窗口过程根据消息的类型对不同的消息进行相关的处理。在SDK编程过程中，用户需要在窗口过程中分析消息的类型和跟消息一起的参数的含义，做不同的处理，相对比较麻烦，而MFC把消息调用的过程给封装起来，使用户能够通过ClassWizard方便的使用和处理Windows的各种消息。

3．MFC的消息实现机制

---- 我们可以看到，在MFC的框架结构下，可以进行消息处理的类的头文件里面都会含有

DECLARE_MESSAGE_MAP()宏,这里主要进行消息映射和消息处理函数的声明。可以进行消息处理的类的实现文件里一般都含有如下的结构。

BEGIN_MESSAGE_MAP(CInheritClass, CBaseClass)

//{{AFX_MSG_MAP(CInheritClass)

//}}AFX_MSG_MAP

END_MESSAGE_MAP()

---- 这里主要进行消息映射的实现和消息处理函数的实现。

---- 所有能够进行消息处理的类都是基于CCmdTarget类的，也就是说CCmdTarget类是所有可以进行消息处理类的父类。CCmdTarget类是MFC处理命令消息的基础和核心。

---- 同时MFC定义了下面的两个主要结构:

AFX_MSGMAP_ENTRY

struct AFX_MSGMAP_ENTRY

{

UINT nMessage; // windows message

UINT nCode; // control code or WM_NOTIFY code

UINT nID;

// control ID (or 0 for windows messages)

UINT nLastID;

// used for entries specifying a range of control id's

UINT nSig;

// signature type (action) or pointer to message #

AFX_PMSG pfn; // routine to call (or special value)

};

和AFX_MSGMAP

struct AFX_MSGMAP

{

#ifdef _AFXDLL

const AFX_MSGMAP* (PASCAL* pfnGetBaseMap)();

#else

const AFX_MSGMAP* pBaseMap;

#endif

const AFX_MSGMAP_ENTRY* lpEntries;

};

其中AFX_MSGMAP_ENTRY结构包含了

一个消息的所有相关信息,其中

nMessage为Windows消息的ID号

nCode为控制消息的通知码

nID为Windows控制消息的ID

nLastID表示如果是一个指定范围的消息被映射的话，

nLastID用来表示它的范围。

nSig表示消息的动作标识

AFX_PMSG pfn 它实际上是一个指向和该消息相应的执行函数的指针。

---- 而AFX_MSGMAP主要作用是两个，一：用来得到基类的消息映射入口地址。二：得到本身的消息映射入口地址。

---- 实际上，MFC把所有的消息一条条填入到AFX_MSGMAP_ENTRY结构中去，形成一个数组，该数组存放了所有的消息和与它们相关的参数。同时通过AFX_MSGMAP能得到该数组的首地址，同时得到基类的消息映射入口地址，这是为了当本身对该消息不响应的时候，就调用其基类的消息响应。

---- 现在我们来分析MFC是如何让窗口过程来处理消息的，实际上所有MFC的窗口类都通过钩子函数

_AfxCbtFilterHook截获消息，并且在钩子函数_AfxCbtFilterHook中把窗口过程设定为AfxWndProc。原来的窗口过程保存在成员变量m_pfnSuper中。

---- 所以在MFC框架下，一般一个消息的处理过程是这样的。

函数AfxWndProc接收Windows操作系统发送的消息。

函数AfxWndProc调用函数AfxCallWndProc进行消息处理，这里一个进步是把对句柄的操作转换成对CWnd 对象的操作。

函数AfxCallWndProc调用CWnd类的方法WindowProc进行消息处理。注意AfxWndProc和AfxCallWndProc 都是AFX的API函数。而WindowProc已经是CWnd的一个方法。所以可以注意到在WindowProc中已经没有关于句柄或者是CWnd的参数了。

方法WindowProc调用方法OnWndMsg进行正式的消息处理，即把消息派送到相关的方法中去处理。消息是如何派送的呢？实际上在CWnd类中都保存了一个AFX_MSGMAP的结构，而在AFX_MSGMAP结构中保存有所有我们用ClassWizard生成的消息的数组的入口，我们把传给OnWndMsg的message和数组中的所有的message进行比较，找到匹配的那一个消息。实际上系统是通过函数AfxFindMessageEntry来实现的。找到了那个message，实际上我们就得到一个AFX_MSGMAP_ENTRY结构，而我们在上面已经提到

AFX_MSGMAP_ENTRY保存了和该消息相关的所有信息，其中主要的是消息的动作标识和跟消息相关的执行函数。然后我们就可以根据消息的动作标识调用相关的执行函数，而这个执行函数实际上就是通过ClassWizard在类实现中定义的一个方法。这样就把消息的处理转化到类中的一个方法的实现上。举一个简单的例子，比如在View中对WM_LButtonDown消息的处理就转化成对如下一个方法的操作。

void CInheritView::OnLButtonDown

(UINT nFlags, CPoint point)

{

// TODO: Add your message

handler code here and/or call default

CView::OnLButtonDown(nFlags, point);

}

注意这里CView::OnLButtonDown(nFlags, point)实际上就是调用CWnd的Default()方法。而Default()方法所做的工作就是调用DefWindowProc对消息进行处理。这实际上是调用原来的窗口过程进行缺省的消息处理。

如果OnWndMsg方法没有对消息进行处理的话，就调用DefWindowProc对消息进行处理。这是实际上是调用原来的窗口过程进行缺省的消息处理。

---- 所以如果正常的消息处理的话，MFC窗口类是完全脱离了原来的窗口过程，用自己的一套体系结构实现消息的映射和处理。即先调用MFC窗口类挂上去的窗口过程，再调用原先的窗口过程。并且用户面对和消息相关的参数不再是死板的wParam和lParam,而是和消息类型具体相关的参数。比如和消息

WM_LbuttonDown相对应的方法OnLButtonDown的两个参数是nFlags和point。nFlags表示在按下鼠标左键的时候是否有其他虚键按下，point更简单，就是表示鼠标的位置。

---- 同时MFC窗口类消息传递中还提供了两个函数，分别为WalkPreTranslateTree和PreTranslateMessage。我们知道利用MFC框架生成的程序，都是从CWinApp开始执行的，而CWinapp实际继承了CWinThread类。在CWinThread的运行过程中会调用窗口类中的WalkPreTranslateTree方法。而WalkPreTranslateTree方法实际上就是从当前窗口开始查找愿意进行消息翻译的类，直到找到窗口没有父类为止。在WalkPreTranslateTree方法中调用了PreTranslateMessage方法。实际上PreTranslateMessage最大的好处是我们在消息处理前可以在这个方法里面先做一些事情。举一个简单的例子，比如我们希望在一个CEdit对象里，把所有的输入的字母都以大写的形式出现。我们只需要在PreTranslateMessage方法中判断message是否为WM_CHAR,如果是的话，把wParam(表示键值)由小写字母的值该为大写字母的值就实现了这个功能。

---- 继续上面的例子，根据我们对MFC消息机制的分析，我们很容易得到除了上面的方法，我们至少还可以在另外两个地方进行操作。

---- 一：在消息的处理方法里面即OnChar中，当然最后我们不再调用CEdit::OnChar(nChar, nRepCnt, nFlags)，而是直接调用DefWindowProc(WM_CHAR,nChar,MAKELPARAM (nRepCnt,nFlags))。因为从我们上面的分析可以知道CEdit::OnChar(nChar, nRepCnt, nFlags)实际上也就是对DefWindowProc方法的调用。

---- 二：我们可以直接重载DefWindowProc方法,对message类型等于WM_CHAR的，直接修改nChar的值即可。

4．小结

---- 通过对MFC类库的分析和了解，不仅能够使我们更好的使用MFC类库，同时，对于我们自己设计和实现框架和类，无疑也有相当大的帮助。

二．MFC的消息映射机制

MFC的设计者们在设计MFC时，紧紧把握一个目标，那就是尽可能使得MFC的代码要小，速度尽可能快。为了这个目标，他们使用了许多技巧，其中很多技巧体现在宏的运用上，实现MFC的消息映射的机制就是其中之一。

同MFC消息映射机制有关的宏有下面几个：

DECLARE_MESSAGE_MAP()宏

BEGIN_MESSAGE_MAP(theClass, baseClass)和END_MESSAGE_MAP()宏

弄懂MFC消息映射机制的最好办法是将找出一个具体的实例，将这些宏展开，并找出相关的数据结构。

DECLARE_MESSAGE_MAP()

DECLARE_MESSAGE_MAP()宏的定义如下：

#define DECLARE_MESSAGE_MAP() \

private: \

static const AFX_MSGMAP_ENTRY _messageEntries[]; \

protected: \

static AFX_DATA const AFX_MSGMAP messageMap; \

virtual const AFX_MSGMAP* GetMessageMap() const; \

从上面的定义可以看出，DECLARE_MESSAGE_MAP()作下面三件事：

定义一个长度不定的静态数组变量_messageEntries[]；

定义一个静态变量messageMap；

定义一个虚拟函数GetMessageMap()；

在DECLARE_MESSAGE_MAP()宏中，涉及到MFC中两个对外不公开的数据结构

AFX_MSGMAP_ENTRY和AFX_MSGMAP。为了弄清楚消息映射，有必要考察一下这两个数据结构的定义。

AFX_MSGMAP_ENTRY的定义

struct AFX_MSGMAP_ENTRY

{

UINT nMessage; // windows message

UINT nCode; // control code or WM_NOTIFY code

UINT nID; // control ID (or 0 for windows messages)

UINT nLastID; // used for entries specifying a range of control id's

UINT nSig; // signature type (action) or pointer to message #

AFX_PMSG pfn; // routine to call (or special value)

};

结构中各项的含义注释已经说明得很清楚了，这里不再多述，从上面的定义你是否看出，AFX_MSGMAP_ENTRY 结构实际上定义了消息和处理此消息的动作之间的映射关系。因此静态数组变量_messageEntries[]实际上定义了一张表，表中的每一项指定了相应的对象所要处理的消息和处理此消息的函数的对应关系，因而这张表也称为消息映射表。再看看AFX_MSGMAP的定义。

（2）AFX_MSGMAP的定义

struct AFX_MSGMAP

{

const AFX_MSGMAP* pBaseMap;

const AFX_MSGMAP_ENTRY* lpEntries;

};

不难看出，AFX_MSGMAP定义了一单向链表，链表中每一项的值是一指向消息映射表的指针（实际上就是_messageEntries的值）。通过这个链表，使得在某个类中调用基类的的消息处理函数很容易，因此，“父类的消息处理函数是子类的缺省消息处理函数”就“顺理成章”了。在后面的“MFC窗口的消息处理”一节中会对此作详细的讲解。

由上述可见，在类的头文件中主要定义了两个数据结构：消息映射表和单向链表。（孙建东总结）BEGIN_MESSAGE_MAP()和END_MESSAGE_MAP()

它们的定义如下：

#define BEGIN_MESSAGE_MAP(theClass, baseClass) \

const AFX_MSGMAP* theClass::GetMessageMap() const \

{ return &theClass::messageMap; } \

AFX_COMDAT AFX_DATADEF const AFX_MSGMAP theClass::messageMap = \

{ &baseClass::messageMap, &theClass::_messageEntries[0] }; \

AFX_COMDAT const AFX_MSGMAP_ENTRY theClass::_messageEntries[] = \

{ \

#define END_MESSAGE_MAP() \

{0, 0, 0, 0, AfxSig_end, (AFX_PMSG)0 } \

}; \

对应BEGIN_MESSAGE_MAP()的定义可能不是一下子就看得明白，不过不要紧，举一例子就很清楚了。对于BEGIN_MESSAGE_MAP(CView, CWnd)，VC预编译器将其展开成下面的形式：

const AFX_MSGMAP* CView::GetMessageMap() const

{

return &CView::messageMap;

}

AFX_COMDAT AFX_DATADEF const AFX_MSGMAP CView::messageMap =

{

&CWnd::messageMap,

&CView::_messageEntries[0]

};

AFX_COMDAT const AFX_MSGMAP_ENTRY CView::_messageEntries[] =

{

至于END_MESSAGE_MAP()则不过定义了一个表示映射表结束的标志项，我想大家对于这种简单的技巧应该是很熟悉的，无需多述。

到此为止，我想大家也已经想到了象ON_COMMAND这样的宏的具体作用了，不错它们只不过定义了一种类型的消息映射项，看看ON_COMMAND的定义：

#define ON_COMMAND(id, memberFxn) \

{ WM_COMMAND, CN_COMMAND, (WORD)id, (WORD)id, AfxSig_vv, (AFX_PMSG)&memberFxn }, 根据上面的定义，ON_COMMAND(ID_FILE_NEW, OnFileNew)将被VC预编译器展开

如下：

{WM_COMMAND, CN_COMMAND, (WORD)id, (WORD)id, AfxSig_vv,

(AFX_PMSG)&OnFileNew},

到此，MFC的消息映射机制已经清楚了，现在提出并解答两个问题以作为对这一节的小结。

为什么不直接使用虚拟函数实现消息处理函数呢？这是一个GOOD QUESTION。前面已经说过，MFC的设计者们在设计MFC时有一个很明确的目标，就是使得“MFC的代码尽可能小，速度尽可能快”，如果采用虚拟函数，那么对于所有的窗口消息，都必须有一个与之对应的虚拟函数，因而对每一个从CWnd派生的类而言，都会有一张很大的虚拟函数表vtbl。但是在实际应用中，一般只对少数的消息进行处理，大部分都交给系统缺省处理，所以表中的大部分项都是无用项，这样做就浪费了很多内存资源，这同MFC设计者们的设计目标是相违背的。当然，MFC所使用的方法只是解决这类问题的方式之一，不排除还有其他的解决方式，但就我个人观点而言，这是一种最好的解决方式，体现了很高的技巧性，值得我们学习。

至于这第二个问题，是由上面的问题引申出来的。如果在子类和父类中出现了相同的消息出来函数，VC编译器会怎么处理这个问题呢？VC不会将它们看作错误，而会象对待虚拟函数类似的方式去处理，但对于消息处理函数(带afx_msg前缀)，则不会生成虚拟函数表vtbl。

MFC下一个消息的处理过程是一般是这样的。

1、_AfxCbtFilterHook截获消息（这是一个钩子函数）

2、_AfxCbtFilterHook把窗口过程设定为AfxWndProc。

3、函数AfxWndProc接收Windows操作系统发送的消息。

4、函数AfxWndProc调用函数AfxCallWndProc进行消息处理。

5、函数AfxCallWndProc调用CWnd类的方法WindowProc进行消息处理。

如何添加自己的消息？

我们已经了解了WINDOW的消息机制，如何加入我们自己的消息呢？好我们来看

一个标准的消息处理程序是这个样子的

在 CWnd 类中预定义了标准 Windows 消息 (WM_XXXX WM是WINDOW MESSAGE的缩写) 的默认处理程序。类库基于消息名命名这些处理程序。例如，WM_PAINT 消息的处理程序在 CWnd 中被声明为：

afx_msg void OnPaint();

afx_msg 关键字通过使这些处理程序区别于其他 CWnd 成员函数来表明 C++ virtual 关键字的作用。但是请注意，这些函数实际上并不是虚拟的，而是通过消息映射实现的。我们在本文的一开始便说明了为什么要这样做。

所有能够进行消息处理的类都是基于CCmdTarget类的，也就是说CCmdTarget类是所有可以进行消息处理类的父类。CCmdTarget类是MFC处理命令消息的基础和核心。

若要重写基类中定义的处理程序，只需在派生类中定义一个具有相同原型的函数，并创建此处理程序的消息映射项。我们通过ClassWizard可以建立大多数窗口消息或自定义的消息，通过ClassWizard可以自动建立消息映射，和消息处理函数的框架，我们只需要把我们要做的事情填空,添加你要做的事情到处理函数。这个非常简单，就不细说了。但是也许我们需要添加一些ClassWizard不支持的窗口消息或自定义消息，那么就需要我们亲自动手建立消息映射和消息处理的框架，通常步骤如下：

第一步：定义消息。Microsoft推荐用户自定义消息至少是WM_USER+100，因为很多新控件也要使用WM_USER 消息。

#define WM_MYMESSAGE (WM_USER + 100)

第二步：实现消息处理函数。该函数使用WPRAM和LPARAM参数并返回LPESULT。

LPESULT CMainFrame::OnMyMessage(WPARAM wParam, LPARAM lParam)

{

// TODO: 处理用户自定义消息，填空就是要填到这里。

return 0;

}

第三步：在类头文件的AFX_MSG块中说明消息处理函数：

// {{AFX_MSG(CMainFrame)

afx_msg LRESULT OnMyMessage(WPARAM wParam, LPARAM lParam);

//}}AFX_MSG

DECLARE_MESSAGE_MAP()

第四步：在用户类的消息块中，使用ON_MESSAGE宏指令将消息映射到消息处理函数中。ON_MESSAGE( WM_MYMESSAGE, OnMyMessage )

MPW内部网络是一个邀请最有影响力的商界女性及时解答职业与领导力问题的在线社区。本周，我们的问题是：千禧一代在进入职场之前应该听从什么建议？以下是Hearsay Social创始人兼CEO史宗玮的回答。

80后和90后们，要知道，你们这个年纪是进入职场最好的时段。抓紧这段时间，尽最大可能地去学习和做事，未来你肯定会感激自己今天的付出的。

回顾我的第一份工作，即便我被要求去做一些看似很卑微、单调或者非常困难的事情时，我也会全力以赴。有的上司是我最不喜欢的类型，但即便如此，我依旧没有放弃、抱怨或懈怠。我会加班到很晚，如果有必要还会通宵达旦地工作，我学会了只有在自己确实无法解决的时候才去寻求帮助；只要是对我的上司和团队有利的事，我都会主动承担。

一旦能够游刃有余地完成上司安排的工作，我就会挑战自己的能力极限。我会不断问自己：“我还能做什么？我还能做些什么让这件事变得更好？”这种心态让我在职业初期便拥有了更开阔的思路，主动向团队提出一些新的想法——虽然并非所有想法都是好的或者被采纳，但总能获得团队的欣赏。最后，“全力以赴”的工作劲头，让我获得上司和同事的尊重。我有幸加入战略对话，这让我有机会了解全局，承担更大的职责。

如果你局限于短期思考，你或许认为这种想法有违常规，但如果你希望在职业

MPW Insider is one of several online communities where the biggest names in business answer timely career and leadership questions. Today’s answer for: What is one piece of advice all millennials should take before entering the workforce? is written by Clara Shih, founder and CEO of Hearsay Social.

Millennials, you could not be entering the workforce at a more exciting time. Seize the day, learn and do the most you possibly can today, and your future self

Looking back at my first job, even when I was asked to do something seemingly menial, unglamorous, or very difficult, I always went all in. In my most trying moments with managers I liked the least, I did not give up, complain, or slack off. I stayed late, pulled all-nighters when necessary, learned to ask for help only when I couldn’t figure it out myself, and basically did whatever it took to make my manager and team look good.

Once I got good at what was asked of me, I challenged myself to go further. I continually asked myself, ―What else can I do? How else can I make this better?‖ This mindset led me early in my career to think bigger and proactively suggest new ideas to the team–certainly not all of them good or accepted, but almost always appreciated. Ultimately, going ―all in‖ won

发展过程中实现工作与生活的平衡，尽早“全力以赴”或许是最明智的选择。你可以获得宝贵的经验和人脉，这些收获将给你的职业发展带来好处。

普华永道等公司的研究显示，80后和90后比他们的前辈更加重视工作与生活的平衡。一方面，许多初入职场的千禧一代会发现有些同龄人在工作中总是非常悠闲，即使混日子，依旧能领到工资。他们或许认为（你可能也会同意）自己比这个体系更聪明。但这样做其实会让他们错失为职业生涯奠定基础的关键时间段。

虽然关于工作与生活平衡的决定很重要，而且人与人之间存在巨大差异，但从长远来看，尽量做最少工作的心态或许并不明智。心理学家梅格?杰伊在其非常有启发性的TED演讲《20岁光阴不再来》中，给所有二十多岁的年轻人敲响了警钟。所谓20岁到30岁是“可以挥霍的十年”这种观念，已经成为一种极其危险的谬论。太多虚度这段光阴的80后和90后将来肯定会后悔不迭的。

就如今天投资100元产生的价值要远远高于10年后投资100元一样，随着时间的推移，出色的工作、职业关系和学习经验会产生“利滚利”效应。你投入的时间、精力和专注同样如此。早些起步能让你获得管理团队的权力，让你在不得不提前离开公司去接孩子放学时，可以将任务交给下属。（财富中文网）

译者：刘进龙/汪皓

审校：任文科me the respect of my manager and colleagues. I got to be a part of strategic conversations that allowed me to understand the bigger picture and play ever-bigger roles.

This idea might seem counterintuitive if you are stuck in short-term thinking, but if you really want work/life balance over a career, going all in as much as possible early may be the smartest thing you can do. You will obtain valuable experience and contacts that will pay dividends throughout your career.

Research from PwC and others suggest that millennials —more than previous generations —value work/life balance. On one end of the spectrum, many millennials new to the workforce will find peers have figured out ways to cruise through their jobs, doing the bare minimum and still collecting their paychecks. They may think (and you may be tempted to agree) they have outsmarted the system. But actually they are the ones losing out on crucial foundational years.

Though decisions regarding work/life balance are important and vary widely from person to person, it may not be wise in the long run to optimize for doing the bare minimum at work. In her insightful TED talk, ―Why 30 is not the new 20,‖ psychologist Meg Jaygives an important

wake-up call to twenty-somethings. The notion that your 20s are a ―throwaway dec ade‖ has become a dangerous fallacy that too many millennials may come to regret later in their careers.

Great work, professional relationships, and learning experiences compound over time, much the way money does —investing $100 today creates much more value than investing $100 a decade from now. The same rings true for your time, energy, and focus. Starting early lets you earn the right to manage a team and have people to delegate to when you have to leave work early to pick up your kid from school.