C++语言99个常见编程错误 常见错误:5：对引用的认识误区

 对于引用的使用，主要存在两个常见的问题。首先，容易与指针搞混。其次，它们未被充分
利用。好多在C++工程使用的指针实际上只是C阵营那些老顽固的杰作，该是引用翻身的时候了。
  引用并非指针。引用只是其初始化物的别名。能对引用做的唯一操作就是将其初始化。一旦
初始化结束，引用就是器初始化物的另一种写法罢了。
  任何能作为左值的复杂表达式都能作为引用的初始化物。
  指向数组的引用保留了数组的尺寸信息，而指针则不保留。
  没有转换成引用类型的强制类型转换操作的一次复制尝试则会无可挽回地失败，强制类型转换
的结果是右值而不是左值。

  指向数组的引用保留了数组尺寸信息，而指针则不保留

main.cpp
#include <iostream>
#include <string>
#include "array.h"

template <typename A>
void print( const A &a, int n ) {
	using namespace std;
	cout << "[ ";
	for( int i = 0; i < n; ++i )
		cout << a[i] << " ";
	cout << ']' << endl;
}

int main() {
	Array<int,12> ia;
	ia = 7;
	print( ia, 12 );
	ia[8] = ia[0] = 2;
	ia[3] = ia[0];
	print( ia, 12 );
	ia = 0;
	print( ia,12 );
	ia.setAll( -1 );
	print( ia, 12 );
	
	Array<std::string,5> sa;
	sa = "Dorian";
	print( sa, 5 );
	sa[4] = sa[0] = "Edgar";
	sa[3] = sa[0];
	print( sa, 5 );
	sa = "Annabel";
	print( sa,5 );
	getchar();
	
	return 0;
}

array.h
#ifndef ARRAY_H
#define ARRAY_H

template <typename T, int n>
class Array {
  public:
    T &operator [](int i)
        { return a_[i]; }
    const T &operator [](int i) const
        { return a_[i]; }
    bool operator ==( const Array &rhs ) const;
    bool operator !=( const Array &rhs ) const
    	{ return !(*this==rhs); }
    Array &operator =( const T & );
    void setAll( const T & );
  private:
    T a_[n];
};

template <class T, int n>
bool Array<T,n>::operator ==( const Array &rhs ) const {
    for( int i = 0; i < n; ++i )
        if( a_[i] != rhs.a_[i] )
            return false;
    return true;
}

template <class T, int n>
Array<T,n> &Array<T,n>::operator =( const T &val ) {
    for( int i = 0; i < n; ++i )
        a_[i] = val;
    return *this;
}

template<class T, int n>
void Array<T,n>::setAll( const T &val )
	{ *this = val; }

#endif

输出
[ 7 7 7 7 7 7 7 7 7 7 7 7 ]
[ 2 7 7 2 7 7 7 7 2 7 7 7 ]
[ 0 0 0 0 0 0 0 0 0 0 0 0 ]
[ -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 ]
[ Dorian Dorian Dorian Dorian Dorian ]
[ Edgar Dorian Dorian Edgar Edgar ]
[ Annabel Annabel Annabel Annabel Annabel ]