矩阵就不用再解释了，写成泛型主要是为了几个方便：
1、方便在栈上分配空间。由于维度在编译期已知，所以可以做到在栈上分配空间。当然如果这个对象是new出来的，自然是在堆上分配，这里说的是在栈上分配这个对象时，矩阵元素所占用的空间也在栈上分配。
2、方便在编译期检查非法的矩阵运算。C++模板的强大推导能力可以在编译期推导出结果矩阵的维度。
3、泛型类在方法内联上具有优势。

这个矩阵类为了能够直接从数组赋值，使用了一个ArrayPorxy类（可参考《Imperfect C++》）。

代码如下：

template <class T, int R, int C>
class Matrix
{
    T matrix[R][C];

public:
    // Big three
    Matrix(void)
    {
        memset(matrix, 0, sizeof(matrix));
    }

    Matrix(const Matrix& rhs)
    {
        memcpy(matrix, rhs.matrix, sizeof(matrix));
    }

    Matrix& operator =(const Matrix& rhs)
    {
        memcpy(matrix, rhs.matrix, sizeof(matrix));
        return *this;
    }

public:
    Matrix(const ArrayProxy<T,R,C>& arr)
    {
        memcpy(matrix, arr.getData(), sizeof(matrix));
    }

    ~Matrix(void)
    {
    }

public:
    T get(int r, int c) const
    {
        assert(c < C && c >= 0 && r < R && r >= 0);
        return matrix[r][c];
    }

    void set(int r, int c, T v)
    {
        assert(c < C && c >= 0 && r < R && r >= 0);
        matrix[r][c] = v;
    }

    int getCols () const
    {
        return C;
    }

    int getRows () const
    {
        return R;
    }

    bool operator == (const Matrix& rhs) const
    {
        return memcmp(matrix, rhs.matrix, sizeof(matrix)) == 0;
    }

    bool operator != (const Matrix& rhs) const
    {
        return !(*this == rhs);
    }
};

template <class T, int R, int C, int C1>
Matrix<T,R,C1> operator* (const Matrix<T,R,C>& lhs, const Matrix<T,C,C1>& rhs)
{
    Matrix<T,R,C1> result;
    for (int r=0; r<R; ++r)
    {
        for (int c=0; c<C1; ++c)
        {
            int value = 0;
            for (int i=0; i<C; ++i)
            {
                value += lhs.get(r,i) * rhs.get(i,c);
            }
            result.set(r,c,value);
        }
    }
    return result;
}

template <class T, class R, class C>
Matrix<T,R,C> operator+ (const Matrix<T,R,C>& lhs, const Matrix<T,R,C>& rhs)
{
   // 
}

template <class T, class R, class C>
Matrix<T,R,C> operator* (const Matrix<T,R,C>& lhs, const Matrix<T,1,1>& rhs)
{
    // 
}

// use local object: 
X x; 
A a; 
std::string s("abc"); 
// … 
x.f(a, s); 

// use remote object : 
proxy<X> x; 
x.connect("my_host"); 
A a; 
std::string s("abc"); 
// … 
x.f(a, s); 

仅使用一个包装层就完成远程调用？从目前的C＋＋来看基本上不可能。 今天突然想到可以使用aspect c++来生成代码，因为aspect c++在生成代码时，也生成了一些简单的元信息，可以在函数里面取得函数的原型、各参数的类型等。 根据0x的描述，我编写了简单的测试代码：

#include <string>
#include <iostream>
#include <sstream>
#include <vector>
using namespace std;

class LoginService
{
public:
	virtual bool login (const string& name, const string& password, string& session) = 0;
	virtual void logout (const string& session) = 0;
};

class RemoteCall
{
public:
	bool connect (const char* host, unsigned short port)
	{
		cout << "connect success" << endl;
		return true;
	}
	bool send (const char* p, size_t len)
	{
		cout << "send: " << endl;
		cout << string(p, len) << endl;
		return true;
	}
	bool recv(char* p, size_t len)
	{
		return true;
	}
};

class RemoteLoginService : public LoginService, public RemoteCall
{
public:
	virtual bool login (const string& name, const string& password, string& session)
	{
		return false;
	}
	virtual void logout (const string& session)
	{
	}
};

int main(int argc, char *argv[])
{
	RemoteLoginService rls;
	rls.connect("localhost", 3957);
	string session;
	rls.login("lijie", "lijie", session);
	rls.logout(session);
	
	return 0;
}

aspect Remote
{
	pointcut remote_class() = "RemoteCall";
	pointcut remote_call() = derived(remote_class()) && !remote_class();

	pointcut virtual_methods() = "% ...::%(...)";

	advice within(remote_call()) && execution(virtual_methods()): before(){
		stringstream ss;
		ss << "\tcall:" << JoinPoint::signature() << endl;
		ss << "\targuments:";
		for (size_t i=0; i<JoinPoint::args(); ++i)
		{
			string arg(tjp->argtype(i));
			if (arg.find("basic_string") != arg.npos)
			{
				ss << *(string*)tjp->arg(i) << "|";
			}
		}
		string send_str = ss.str();
		tjp->target()->send (send_str.c_str(), send_str.size());
	}

	advice within(remote_call()) && execution(virtual_methods()): after(){
		vector<char> buffer(1024, '\0');
		tjp->target()->recv (&(*buffer.begin()), buffer.size());
		// 解析接收的数据，远程调用结果写入tjp->result()指向的内存
	}
};