遇君阁

有一次我在VS中遇到这样的一个编译错误，代码如下（程序1）：
typedef char * string;

class A
{
private:
 char value[256];
public:
 const string getValue() const
 {
  return value;
 }
};

int _tmain(int argc, _TCHAR* argv[])
{
 return 0;
}
编译错误：error C2440: 'return' : cannot convert from 'const char [256]' to 'const string'
为什么会有这样的编译错误呢？不是数组名可以转换成一个指针吗（此主题可参考），按此原理类推应该可以实现此类型转换。于是我改写代码（程序2）：
typedef char * string;

class A
{
private:
 char value[256];
public:
 const char * getValue() const
 {
  return value;
 }
};

int _tmain(int argc, _TCHAR* argv[])
{
 return 0;
}
这时编译这段代码却没有错误乐。为什么呢？原因在于在程序1中const从整体上修饰类型别名string（char *），那么就相当于char * const，表示char类型的指针为常量，所以就出现上述的编译错误。错误的根本原因就是我把typedef主观认为可以与#define等同，而typedef实际上却是定义一种类型的别名，而不只是简单的宏替换。这次经历也告诉我一个道理：不能凭主观或者说错误的观点进行推测，而应该认识到实践才是检验真理的唯一标准。

1. Type the Unicode (hexadecimal) value of the character.

   Note  The value string can also begin with U+.

2. Press ALT+X.

   Microsoft Word replaces the string to the left of the insertion point with the character you specified.

字节对齐的目的是什么？
1.增加内存利用率
2.增加程序的运行效率
但这两点有时候在内存对齐时却是相互违背的。比如我们来对比下面的程序，在此之前声明一下我的环境，x86（P4）,VC 2005：
程序1
#pragma pack(4)
class A
{
public:
 char a;
 int aa;

};

程序2
#pragma pack(1)
class B
{
public:
 char a;
 int aa;

};
类A的size是8,而B的size是5,A相对于B来说浪费了内存空间，但同时我们还要看看对于A和B中的成员aa，aa的地址在类A中是可以被4整除（即：addr(A::aa)%4=0）,而aa在类B中由于内存对齐方式是1,所以aa的地址无法被4整除（即：addr(A::aa)%4!=0）．那么由于在x86（32位）上，从无法被4整除的地址边界去访问变量，会影响效率，具体原因已经超出了本文的讨论范围，以后用另一篇文章讨论．这里只放一个测试用例，如果有兴趣的朋友可以运行一下（VC 2005）：
测试用例１：
inline   unsigned   __int64   GetCycleCount(void)  
{  
      _asm         _emit   0x0F  
      _asm         _emit   0x31  
}

int _tmain(int argc, _TCHAR* argv[])
{
 long long l = 3000000000000;

 unsigned   __int64 begin = GetCycleCount();
 
 for(long long i = 1000000000; i > 0; i--)
 {
  // Empty the cache in CPU.
  l--;
  // Access the memory as the address can be divided by 4
  __asm
  {
   
   mov ecx,dword ptr [l]
  }
 }
 
 unsigned   __int64 end = GetCycleCount();
 printf("The elapse time is:%I64d\n", end - begin);
 return 0;
}
测试用例２：
inline   unsigned   __int64   GetCycleCount(void)  
{  
      _asm         _emit   0x0F  
      _asm         _emit   0x31  
}

int _tmain(int argc, _TCHAR* argv[])
{
 long long l = 3000000000000;

 unsigned   __int64 begin = GetCycleCount();
 
 for(long long i = 1000000000; i > 0; i--)
 {
  // Empty the cache in CPU.
  l--;
  // Access the memory as the address can not be divided by 4
  __asm
  {
   
   mov ecx,dword ptr [l+1]
  }
 }
 
 unsigned   __int64 end = GetCycleCount();
 printf("The elapse time is:%I64d\n", end - begin);
 return 0;
}
比较测试用例１与测试用例２打印出来的时间，你就可以从直观上得到访问奇地址时效率上的损失．
所以我的结论是：
在使用字节对齐时，请仔细考虑你要的是效率还是要的是内存，并在写程序时注意。

详细设计时应该注意的Item：
条款03：尽可能使用const
Use const whenever possible.
条款18：让接口容易被正确使用，不易被误用
Make interfaces easy to use correctly and hard to use incorrectly.
条款19：设计class犹如设计type
Treat class design as type design.
条款20：宁以pass-by-reference-to-const替换pass-by-value
Prefer pass-by-reference-to-const to pass-by-value.
条款21：必须返回对象时，别妄想返回其reference
Don't try to return a reference when you must return an object.
条款22：将成员变量声明为private
Declare data members private.
条款23：宁以non-member、non-friend替换member函数
Prefer non-member non-friend functions to member functions.
条款24：若所有参数皆需类型转换，请为此采用non-member函数
Declare non-member functions when type conversions should apply to all parameters.
条款28：避免返回handles指向对象内部成分
Avoid returning "handles" to object internals.
条款32：确定你的public继承塑模出is-a关系
Make sure public inheritance models "is-a."
条款34：区分接口继承和实现继承
Differentiate between inheritance of interface and inheritance of implementation.
条款35：考虑virtual函数以外的其他选择
Consider alternatives to virtual functions.
条款36：绝不重新定义继承而来的non-virtual函数
Never redefine an inherited non-virtual function.
条款37：绝不重新定义继承而来的缺省参数值
Never redefine a function's inherited default parameter value.
条款38：通过复合塑模出has-a或"根据某物实现出"
Model "has-a" or "is-implemented-in-terms-of" through composition.
条款39：明智而审慎地使用private继承
Use private inheritance judiciously.
条款40：明智而审慎地使用多重继承
Use multiple inheritance judiciously.

写代码时应该注意的Item：
条款02：尽量以const, enum, inline替换 #define
Prefer consts,enums, and inlines to #defines.
条款04：确定对象被使用前已先被初始化
Make sure that objects are initialized before they're used.
条款05：了解C++ 默默编写并调用哪些函数
Know what functions C++ silently writes and calls.
条款06：若不想使用编译器自动生成的函数，就该明确拒绝
Explicitly disallow the use of compiler-generated functions you do not want.
条款07：为多态基类声明virtual析构函数
Declare destructors virtual in polymorphic base classes.
条款09：绝不在构造和析构过程中调用virtual函数
Never call virtual functions during construction or destruction.
条款10：令operator= 返回一个reference to *this
Have assignment operators return a reference to *this.
条款11：在operator= 中处理“自我赋值”
Handle assignment to self in operator=.
条款12：复制对象时勿忘其每一个成分
Copy all parts of an object.
条款25：考虑写出一个不抛异常的swap函数
Consider support for a non-throwing swap.
条款26：尽可能延后变量定义式的出现时间
Postpone variable definitions as long as possible.
条款27：尽量少做转型动作
Minimize casting.
条款30：透彻了解inlining的里里外外
Understand the ins and outs of inlining.
条款31：将文件间的编译依存关系降至最低
Minimize compilation dependencies between files.
条款33：避免遮掩继承而来的名称
Avoid hiding inherited names.

异常应该注意的Item：
条款08：别让异常逃离析构函数
Prevent exceptions from leaving destructors.
条款29：为“异常安全”而努力是值得的
Strive for exception-safe code.

资源管理
条款13：以对象管理资源
Use objects to manage resources.
条款14：在资源管理类中小心coping行为
Think carefully about copying behavior in resource-managing classes.
条款15：在资源管理类中提供对原始资源的访问
Provide access to raw resources in resource-managing classes.
条款16：成对使用new和delete时要采取相同形式
Use the same form in corresponding uses of new and delete.
条款17：以独立语句将newed对象置入智能指针
Store newed objects in smart pointers in standalone statements.
条款49：了解new-handler的行为
Understand the behavior of the new-handler.
条款50：了解new和delete的合理替换时机
Understand when it makes sense to replace new and delete.
条款51：编写new和delete时需固守常规
Adhere to convention when writing new and delete.
条款52：写了placement new也要写placement delete
Write placement delete if you write placement new.

模板与泛型编程
条款41：了解隐式接口和编译期多态
Understand implicit interfaces and compile-time polymorphism.
条款42：了解typename的双重意义
Understand the two meanings of typename.
条款43：学习处理模板化基类内的名称
Know how to access names in templatized base classes.
条款44：将与参数无关的代码抽离templates
Factor parameter-independent code out of templates.
条款45：运用成员函数模板接受所有兼容类型
Use member function templates to accept "all compatible types."
条款46：需要类型转换时请为模板定义非成员函数
Define non-member functions inside templates when type conversions are desired.
条款47：请使用traits classes表现类型信息
Use traits classes for information about types.
条款48：认识template元编程
Be aware of template metaprogramming.

杂项
条款01：视C++ 为一个语言联邦
View C++ as a federation of languages
条款53：不要轻忽编译器的警告
Pay attention to compiler warnings.
条款54：让自己熟悉包括TR1在内的标准程序库
Familiarize yourself with the standard library, including TR1.
条款55：让自己熟悉Boost
Familiarize yourself with Boost.

我个人感觉原来的目录容易理解，却不容易记忆。因为很大一部分的人看过Effective C++或者都还没有全部看完这本书，可他们都感觉虽然暂时理解了但没有办法一下把书里面所有的知识都应用于实践，所以我觉得如果是这样还不如在看过书以后对其进行纯记忆，以后再慢慢理解融会贯通进行使用，这样的效果更加明显。这也是我为什么重新划分原书目录的原因--暂时的理解不如先记忆后理解,希望对大家有用.

1． 一维数组

如：int array[100];

array这个数组名可以转换成指向这个一维数组的指针，所以

int * p = array + 1;              //array 转换成指针

int * foo(int * ptr);

{

return array;        //array 转换成指针

}

foo(array);                   //array 转换成指针

2． 二维数组

如：int array[10][20];

array这个数组名也可以转换成一个指针，但它的类型不是int **（指针的指针），而是一个指向一维数组的指针，这个一维数组拥有20个元素。所谓二维数组其实就是数组的数组，所以二维数组名解释为指向数组的指针是合理的。所以

int (*p)[20] = array;             // array 转换成指向一维数组的指针

typedef int (*T)[20];

T foo(int  ptr[][20])

{

return array;        // array 转换成指向一维数组的指针

}

T foo1(int  (*ptr)[20])

{

return array;        // array 转换成指向一维数组的指针

}

foo(array);                   // array 转换成指向一维数组的指针

      二维数组的定义可以参考： http://blog.vckbase.com/eyesonyhm/articles/23500.html

3． 三维数组

同理……

注意：阿

数组≠指针。

数组名是一个常量指针。