源码路径：~/opencv-2.4.9/modules/core/include/opencv2/core/core.hpp

where _InputArray is a class that can be constructed from [Mat](http://docs.opencv.org/master/d3/d63/classcv_1_1Mat.html), [Mat_](http://docs.opencv.org/master/df/dfc/classcv_1_1Mat__.html)<T>, [Matx](http://docs.opencv.org/master/de/de1/classcv_1_1Matx.html)<T, m, n>, std::vector<T>, std::vector<std::vector<T> > or std::vector<[Mat](http://docs.opencv.org/master/d3/d63/classcv_1_1Mat.html)>. It can also be constructed from a matrix expression.

typedef const _InputArray& InputArray;
typedef InputArray InputArrayOfArrays;
typedef const _OutputArray& OutputArray;
typedef OutputArray OutputArrayOfArrays;
typedef OutputArray InputOutputArray;
typedef OutputArray InputOutputArrayOfArrays;

/*!
Proxy datatype for passing Mat's and vector<>'s as input parameters
*/
class CV_EXPORTS _InputArray
{
public:
enum {
KIND_SHIFT = ,
FIXED_TYPE = 0x8000 << KIND_SHIFT,
FIXED_SIZE = 0x4000 << KIND_SHIFT,
KIND_MASK = ~(FIXED_TYPE|FIXED_SIZE) - ( << KIND_SHIFT) + ,

     NONE              =  << KIND\_SHIFT,  
     MAT               =  << KIND\_SHIFT,  
     MATX              =  << KIND\_SHIFT,  
     STD\_VECTOR        =  << KIND\_SHIFT,  
     STD\_VECTOR\_VECTOR =  << KIND\_SHIFT,  
     STD\_VECTOR\_MAT    =  << KIND\_SHIFT,  
     EXPR              =  << KIND\_SHIFT,  
     OPENGL\_BUFFER     =  << KIND\_SHIFT,  
     OPENGL\_TEXTURE    =  << KIND\_SHIFT,  
     GPU\_MAT           =  << KIND\_SHIFT,  
     OCL\_MAT           = << KIND\_SHIFT  
 };  
 \_InputArray();

 \_InputArray(const Mat& m);  
 \_InputArray(const MatExpr& expr);  
 template<typename \_Tp> \_InputArray(const \_Tp\* vec, int n);  
 template<typename \_Tp> \_InputArray(const vector<\_Tp>& vec);  
 template<typename \_Tp> \_InputArray(const vector<vector<\_Tp> >& vec);  
 \_InputArray(const vector<Mat>& vec);  
 template<typename \_Tp> \_InputArray(const vector<Mat\_<\_Tp> >& vec);  
 template<typename \_Tp> \_InputArray(const Mat\_<\_Tp>& m);  
 template<typename \_Tp, int m, int n> \_InputArray(const Matx<\_Tp, m, n>& matx);  
 \_InputArray(const Scalar& s);  
 \_InputArray(const double& val);  
 // < Deprecated  
 \_InputArray(const GlBuffer& buf);  
 \_InputArray(const GlTexture& tex);  
 // >  
 \_InputArray(const gpu::GpuMat& d\_mat);  
 \_InputArray(const ogl::Buffer& buf);  
 \_InputArray(const ogl::Texture2D& tex);

 virtual Mat getMat(int i=-) const;  
 virtual void getMatVector(vector<Mat>& mv) const;  
 // < Deprecated  
 virtual GlBuffer getGlBuffer() const;  
 virtual GlTexture getGlTexture() const;  
 // >  
 virtual gpu::GpuMat getGpuMat() const;  
 /\*virtual\*/ ogl::Buffer getOGlBuffer() const;  
 /\*virtual\*/ ogl::Texture2D getOGlTexture2D() const;

 virtual int kind() const;  
 virtual Size size(int i=-) const;  
 virtual size\_t total(int i=-) const;  
 virtual int type(int i=-) const;  
 virtual int depth(int i=-) const;  
 virtual int channels(int i=-) const;  
 virtual bool empty() const;

#ifdef OPENCV_CAN_BREAK_BINARY_COMPATIBILITY
virtual ~_InputArray();
#endif

 int flags;  
 void\* obj;  
 Size sz;  

};

/*!
Proxy datatype for passing Mat's and vector<>'s as input parameters
*/
class CV_EXPORTS _OutputArray : public _InputArray
{
public:
_OutputArray();

 \_OutputArray(Mat& m);  
 template<typename \_Tp> \_OutputArray(vector<\_Tp>& vec);  
 template<typename \_Tp> \_OutputArray(vector<vector<\_Tp> >& vec);  
 \_OutputArray(vector<Mat>& vec);  
 template<typename \_Tp> \_OutputArray(vector<Mat\_<\_Tp> >& vec);  
 template<typename \_Tp> \_OutputArray(Mat\_<\_Tp>& m);  
 template<typename \_Tp, int m, int n> \_OutputArray(Matx<\_Tp, m, n>& matx);  
 template<typename \_Tp> \_OutputArray(\_Tp\* vec, int n);  
 \_OutputArray(gpu::GpuMat& d\_mat);  
 \_OutputArray(ogl::Buffer& buf);  
 \_OutputArray(ogl::Texture2D& tex);

 \_OutputArray(const Mat& m);  
 template<typename \_Tp> \_OutputArray(const vector<\_Tp>& vec);  
 template<typename \_Tp> \_OutputArray(const vector<vector<\_Tp> >& vec);  
 \_OutputArray(const vector<Mat>& vec);  
 template<typename \_Tp> \_OutputArray(const vector<Mat\_<\_Tp> >& vec);  
 template<typename \_Tp> \_OutputArray(const Mat\_<\_Tp>& m);  
 template<typename \_Tp, int m, int n> \_OutputArray(const Matx<\_Tp, m, n>& matx);  
 template<typename \_Tp> \_OutputArray(const \_Tp\* vec, int n);  
 \_OutputArray(const gpu::GpuMat& d\_mat);  
 \_OutputArray(const ogl::Buffer& buf);  
 \_OutputArray(const ogl::Texture2D& tex);

 virtual bool fixedSize() const;  
 virtual bool fixedType() const;  
 virtual bool needed() const;  
 virtual Mat& getMatRef(int i=-) const;  
 /\*virtual\*/ gpu::GpuMat& getGpuMatRef() const;  
 /\*virtual\*/ ogl::Buffer& getOGlBufferRef() const;  
 /\*virtual\*/ ogl::Texture2D& getOGlTexture2DRef() const;  
 virtual void create(Size sz, int type, int i=-, bool allowTransposed=false, int fixedDepthMask=) const;  
 virtual void create(int rows, int cols, int type, int i=-, bool allowTransposed=false, int fixedDepthMask=) const;  
 virtual void create(int dims, const int\* size, int type, int i=-, bool allowTransposed=false, int fixedDepthMask=) const;  
 virtual void release() const;  
 virtual void clear() const;

#ifdef OPENCV_CAN_BREAK_BINARY_COMPATIBILITY
virtual ~_OutputArray();
#endif
};