is it possible to implement it in this way

this is just a program that can no be compiled successfully. thus, could anyone provides a little advice for this. thanks

Code:

// MMath.h : interface of the MMath class

#pragma once

#ifndef  __MMATH_H__
#define  __MMATH_H__

#include <iostream>
#include <iomanip>
#include <vector>

#endif

template <typename T, size_t R, size_t C>
class   YMatrix
{
	// Constructor & Destructor
public:
	YMatrix();
	~YMatrix();
//	YMatrix(std::vector< std::vector<T> > & valv);  // a overload constructor
	YMatrix(T (&arr));

	// Operations
public:

	//for test
public:
//	YMatrix(T val);

//	T & operator=(T ori);
	void yout();
//	void yset(T val);

	// members
private:
//	std::vector< std::vector<T> > mem;   // 2 dims vector for storing matrix data
	T test;                              // a private member variable for test program running
	T mem[R][C];
};

Code:

#include "mat.h"

template<typename T, size_t R, size_t C> YMatrix<T,R,C>::YMatrix() 
{

};

template<typename T, size_t R, size_t C> YMatrix<T,R,C>::~YMatrix() 
{

};

template<typename T, size_t R, size_t C> void YMatrix<T,R,C>::yout()
{
	for(int i=0; i<R; i++)
	{
		for(int j=0; j<C; j++)
			std::cout<<mem[i][j];
		std::cout<<std::endl;
	}
};

Code:

#include "mat.cpp"

void test()
{
	float ar[2][2] = {{1,2},{3.5,4.0}};
	YMatrix<float, 2, 2> Ma(ar);
	Ma.yout();
}
int main(void)
{
	return 0;
}

When dealing with templates, both the definition and the implementation must be in the same compilation unit (usually the same file).

Jim

In other words, get rid of mat.cpp and put its contents back into mat.h

You should also not include a destructor when it has no work to do and is non-virtual.

Code:

#ifndef  __MMATH_H__
#define  __MMATH_H__

Header names beginning with underscores are reserved.

Originally Posted by 1999 C Standard

7.1.3 Reserved identifiers

Each header declares or defines all identifiers listed in its associated subclause, and optionally declares or defines identifiers listed in its associated future library directions subclause and identifiers which are always reserved either for any use or for use as file scope identifiers.

All identifiers that begin with an underscore and either an uppercase letter or another underscore are always reserved for any use.
All identifiers that begin with an underscore are always reserved for use as identifiers with file scope in both the ordinary and tag name spaces.
Each macro name in any of the following subclauses (including the future library directions) is reserved for use as specified if any of its associated headers is included; unless explicitly stated otherwise (see 7.1.4).
All identifiers with external linkage in any of the following subclauses (including the future library directions) are always reserved for use as identifiers with external linkage.154
Each identifier with file scope listed in any of the following subclauses (including the future library directions) is reserved for use as a macro name and as an identifier with file scope in the same name space if any of its associated headers is included.
No other identifiers are reserved. If the program declares or defines an identifier in a context in which it is reserved (other than as allowed by 7.1.4), or defines a reserved identifier as a macro name, the behavior is undefined.

If the program removes (with #undef) any macro definition of an identifier in the first group listed above, the behavior is undefined.

154) The list of reserved identifiers with external linkage includes errno, math_errhandling, setjmp, and va_end.

o_O
I think it would be appropriate to citate the C++ standard while in the C++ forum.
Although with this, it doesn't matter, since the same thing applies to C++ too.