Matlab与VC混合编程之三

Matlab与VC混合编程之三

1. 有没有优雅的使用方式？

在《Matlab与VC混合编程之二》中我们学会了如何使用向量或者矩阵在VC与Matlab
COM组件之间传递参数。在第二章的实现中，标量和向量的使用方式勉强可以接受，矩阵的使用方式简直令人发狂。而我们的大多数科学计算或者工程计算都需要用到矩阵，如何改进对矩阵（二维数组）的访问方式，是本章要回答的问题。在本章中，我们使用用C++的类来封装这种复杂性，把标量和向量作为矩阵的特殊情况，使用类来表达矩阵的概念。经过封装之后，以后再使用时就直接调用类的接口，实现了简单优雅访问Matlab生产的COM组件。首先讲解一些C++的类基本概念，之后讲解矩阵了matrix的实现方式，最后在附录中给出完整的源代码。

2. 基本概念

a.需要几个类来封装

使用类来表示概念和针对接口编程，是设计一个良好的类需要遵循的原则。在VC与Matlab
COM的访问中，我们需要“矩阵”这一概念。使用Matlab时会注意到matlab的几乎所有函数的输入输出参数都是矩阵，向量和标量只是矩阵的特殊形式，向量是只有一行（行向量）或者只有一列（列向量）的矩阵，标量是只有一行一列的矩阵。理解了这一点之后，我们就只需要一个概念，即矩阵。所以我们只需要实现或者定义一个类matrix。

b.类的接口有哪些

类的接口指类的共有方法（public函数）。类的接口有哪些，是由使用该类的客户的上下文（环境）来确定的。也就是说在定义类的接口时要站在客户（使用类的人或者代码）的角度去考虑问题。在这里，使用matrix时，我们需要能够将数据赋值到matrix中，能够将matrix作为输入参数传递给Matlab
COM的接口函数去完成计算，能够将matrix作为输出参数传递给Matlab
COM的接口函数从而获得计算的结果，能够将matrix中的数据获取出来。

如图1所示。





图1 matrix封装示意图
写成伪代码的形式如下：

double dx[2][2] = {1,2,3,4}; //客户需要计算的数据

matrix mx, my; //matrix变量的定义

mx.setMatrix(2,2,dx);//将客户数据赋值到matrix中

long varNum = 1;

pInterface->calcSin(varNum, &my,
mx); //matrix作为输入参数和输出参数,假定这里的COM函数是求正弦值

double dy[2][2] = {0}; //客户需要获取结果数据

my.getData(dy); //将matrix中的数据获取出来

站在客户的角度，才能设计出优良的类（抽象、概念）。

3. matrix的实现方式

a. matrix接口初步

根据第二节的分析，我们的matrix的接口应该是这样的：

class matrix

{

public:

matrix(); //默认构造函数

matrix(int nRows, int nCols); //构造nRows行、nCols列的矩阵，所有元素初始化为0

matrix(int nRows, int nCols, double*
pdArray);//构造nRows行、nCols列的矩阵，矩阵元素为数组的内容

matrix(const matrix& other);
//拷贝构造函数，允许使用matrix对象构造

void setMatrix(int nRows, int nCols, double* pdArray);
//设置矩阵的大小和数据

void setSize(int nRows, int nCols); //设置矩阵的大小，以后再设置数据

void setData(double* pdArray, ); //设置数据

Size getSize(); //返回矩阵的大小

void getData(double* pdArray); //获得矩阵的数据

operator VARIANT();
//类型转换运算符,允许在函数的输入参数中使用VARIANT的地方使用matrix

//matlab com的接口函数的输入参数都是VARIANT型的变量

VARIANT* operator&();
//取地址运算符重载，允许在函数的输出参数中使用VARIANT的地方使用matrix

//matlab com的接口函数的输出参数都是VARIANT型的变量的指针(取地址)

}

b.增加一维数组和二维数组的描述

i.一维数组和二维数组的区别

在《Matlab与VC混合编程之二》中我们提到了VARIANT存储数组时是按照列优先的顺序来存储的。如果是一维数据，不管是按照行优先原则还是列优先的原则，访问其内部元素的顺序是相同的。比如double
a[3]={1,2,3}。若按照行优先来存储，先存储第一行，那么在内存中的顺序是1,2,3.若按照列优先来存储，先存储第一列，1，再存储第二列2，最后存储第三列3，元素在内存中的顺序依然是1,2,3.所以对于一维数组，不需要进行数据转换。

对于二维数据（矩阵），则必须进行数据转换。仍然使用《Matlab与VC混合编程之二》中的例子。一个3行2列的数组（矩阵）

double array[3][2] = {1, 2,

3, 4,

5, 6};

按照行优先的顺序存储，在VC中是先存第1行{1,2},再存第2行{3,4},再存第3行{5,6}。即在内存中的顺序是1,2,3,4,5,6.

如果直接将array的数据拷贝到VARIANT的SAFEARRAY中，那么SAFEARRAY在内存中的顺序仍然是1,2,3,4,5,6.但由于SAFEARRAY是按照列优先来存放和访问的。SAFEARRAY的第一维是列，列数是2，第二维是行，行数是3。SAFEARRAY在进行访问时，先访问第1列{1,2,3},再访问第2列{4,5,6}。即这时将SAFEARRAY写成矩阵的形式是
[1 4,
2
5,
3
6]。显然不是我们要传入的矩阵array.所以，在从二维数组到SAFEARRAY的赋值前必须进行转换。
现在首先对array取转置,得到二维数组b[2][3]={1,3,5，

2,4,6}。之后将b的内存直接拷贝到VARIANT的SAFEARRAY中。由于b在内存中的顺序是1,3,5,2,4,6.那么SAFEARRAY是按照列优先来访问，先访问第1列{1,3,5}，再访问第2列{2,4,6}.写成矩阵的形式是
[1,2,
3,4,
5,6]。正好是我们所要传入的矩阵。所以转换的方法是，首先将二维数组array求转置得到新的二维数组，将该二维数组的数据直接拷贝到SAFEARRAY中。同时，在输出数据时，需要将SAFEARRAY的数据拷贝出来，经过转置，放置到接受输出数据的二维数组中。见图2.




图2 matrix实现示意图
为了区分一维数组和二维数组，定义了枚举enum ArrayType{Dim1, Dim2};
当使用matrix表示向量（行向量或者列向量，默认是列向量）或者标量时，使用Dim1，表示（Dimension
1，一维）。当使用matrix表示矩阵时，如果用户没有在外部对输入的二维数组使用转置，使用Dim2，matrix会在构造时进行装置；如果用户在外部自己实现了转置，那么使用Dim1，matrix不会再进行转置。即Dim1和Dim2的区别是Dim1构造时matrix时直接拷贝传入的数组的数据，Dim2将传入的数据转置后拷贝到内部的VARIANT。
ii.
数组维数的描述
使用了matrix的内部类struct
Size来描述数组的行数和列数。
class matrix {
public：
struct Size

{

int m_nRows; //矩阵的行数

int m_nCols; //矩阵的列数

Size() : m_nRows(0), m_nCols(0){ }

Size(int nRows, int nCols) : m_nRows(nRows), m_nCols(nCols){
}

};
};

c. 兼容已有的程序
为了兼容已有的程序，需要增加VARIANT和matrix互相赋值的接口。使用构造函数和setMatrix函数重载来用VARIANT构造和设置matrix；使用类型转换运算符来将matrix转换为VARIANT。
d.
完整接口的matirx
经过以上分析，具备较完备接口的matrix的定义如下：
class matrix

{

public:

//Dim1：一维数组，表示向量；Dim2：二维数组，表示矩阵。将标量看成是只有一个元素的向量或者矩阵。

enum ArrayType{Dim1, Dim2};

struct Size

{

int m_nRows; //矩阵的行数

int m_nCols; //矩阵的列数

Size() : m_nRows(0), m_nCols(0){ }

Size(int nRows, int nCols) : m_nRows(nRows), m_nCols(nCols){
}

};

public:

matrix();

matrix(int nRows, int nCols); //构造nRows行、nCols列的矩阵，所有元素初始化为0

//构造nRows行、nCols列的矩阵，所有元素初始化为一维数组或二维数组的内容

matrix(int nRows, int nCols, double* pdArray, ArrayType
arrType);

matrix(const VARIANT& var); //用VARIANT构造

matrix(const matrix& other);
//拷贝构造函数，允许使用matrix对象构造

void setMatrix(int nRows, int nCols, double* pdArray, ArrayType
arrType); //设置矩阵的大小和数据

void setMatirx(const VARIANT& var);
//用VARIANT设置矩阵

void setSize(int nRows, int nCols); //设置矩阵的大小，默认构造后再设置数据

void setData(double* pdArray, ArrayType arrType);
//默认构造后再设置数据

Size getSize(); //返回矩阵的大小

void getData(double* pdArray, ArrayType arrType); //获得矩阵的数据

public: //matrix 与 VARIANT的转换

operator VARIANT(); //类型转换运算符,允许在函数的输入参数中使用VARIANT的地方使用matrix

//matlab com的接口函数的输入参数都是VARIANT型的变量

VARIANT* operator&();
//取地址运算符重载，允许在函数的输出参数中使用VARIANT的地方使用matrix

//matlab com的接口函数的输出参数都是VARIANT型的变量的指针(取地址)

matrix& operator=(const matrix&
other); //重载赋值运算符,允许matrix之间相互赋值

virtual ~matrix();

};

4. 优雅的使用matrix类

为了演示matrix的使用，这里使用matrix重写了《Matlab与VC混合编程之二》中的OnButtonTest()。

void CTestMyCalcDlg::OnButtonTest()

{

::CoInitialize(NULL);
//a.初始化COM。

IMyCalc *pICalc; //声明一个接口

//b.创建COM接口。

HRESULT hr =
::CoCreateInstance(CLSID_MyCalc,
//你使用的COM对象的ID（CLaSs ID)

NULL,

CLSCTX_ALL,

IID_IMyCalc,
//你使用的COMCOM对象接口的ID（Interface ID)

(LPVOID*)&pICalc);//这里用&pIdraw使pIdraw指向接口的地址

if (FAILED(hr)) //错误检查并处理

{

//。。。

return;

}

//c.使用COM接口，这一段使用的数据类型是VARIANT

long nvar = 1; //输出变量的个数

//i. 使用mycross

matrix ca,cb,cy;
//ca,cb输入参数，cy输出参数初始化在默认构造函数已经完成

//对向量ca,cb赋值，以double型为例

//...Action_1

double array1[3] = {1, 0,
0};
//待存入的一维数组

double array2[3] = {0, 1,
0};
//带存入的一维数组

ca.setMatrix(1,3,array1,
matrix::Dim1); //数组维数定义和数据变换自动完成，行向量

cb.setMatrix(1,3,array2,
matrix::Dim1);
//这里也可以将ca、cb定义成列向量，setMatrix(3,1,...);

hr = pICalc->mycross(nvar,
&cy, ca, cb);
//输出变量使用&cy形式才能得到返回值。

//从cy获取计算结果

//...Action_2

double array3[3] = {0};

cy.getData(array3, matrix::Dim1);

matrix::Size s1 = cy.getSize();

//array3结果是{0,0,1},结果正确。

//ii. 使用mydet

matrix dx,dy; //dx输入参数，dy输出参数, 默认构造函数完成初始化

//对向量dx赋值，以double型为例

//...Action_3

double array4[2][2] = {1, 0, 0, 4};

dx.setMatrix(2,2,(double*)array4,
matrix::Dim2); //数组维数定义和数据变换自动完成

hr = pICalc->mydet(nvar,
&dy, dx);
//输出变量使用&dy形式才能得到返回值。

//从dy获取计算结果

//...Action_4

double dresult = 0;

dy.getData(&dresult,
matrix::Dim1);

matrix::Size s2 = dy.getSize();

//dresult = 4,结果正确

//iii. 使用myinv

matrix ix,iy;
//ix输入参数，iy输出参数。ix，iy在默认构造函数已经被初始化

//对向量ix赋值，以double型为例

//Action_5

double array5[3][3] = {1, 0, 0, 0, 1, 0, 0, 0,
1};

ix.setMatrix(3, 3, (double*)array5,
matrix::Dim2); //数组维数定义和数据变换自动完成

hr = pICalc->myinv(nvar,
&iy, ix);
//输出变量使用&iy形式才能得到返回值。

//从iy获取计算结果

//...Action_6

double array6[3][3] = {0};

iy.getData((double*)array6, matrix::Dim2);

matrix::Size s3 = iy.getSize();

//array6结果是{{1,0,0}, {0,1,0}, {0,0,1}}，结果正确。

//d.退出COM。

CoUninitialize();

}

5. 优雅的背后，matrix封装类

在第4节，我们使用matrix类的接口重写了《Matlab与VC混合编程之二》中VC与Matlab
COM的接口函数进行交互的程序。可以明显看到，使用了matrix后，程序代码和程序逻辑得到很大的改善。那么，matrix的接口是怎么实现的。附录8给出优雅的背后，matrix的完整实现代码。

6. 有没有完整的说明matlab COM？

我们采用COM组件方式的matlab与VC混合编程给予了详细的介绍。这里距离完整还差一点，就是我们的程序怎么发布。在Matlab7.0及以下版本中，在Matlab
COM Builder窗口中点击菜单Component->Package
component；在在Matlab2007b及以上版本中，点击工具栏Build后面的Package按钮。弹出Package
Files对话框(Matlab 7.0版本），见图3，将“Include
MCR”选中，点击左下方的Create，等待几十秒，完成COM组件封装。在Matlab的当前目录Current
Directary窗口下，找到distrib文件夹下的组件名的可执行程序YourComName.exe，将该文件复制出来，跟你的VC程序编译链接生成的可执行程序.exe放在一起打包发布就行了。





图3 matlab com package 窗口
7.其他的VC和Matlab混合编程的方式呢？

对于matlab与VC混合编程的实现方法之一“采用COM组件方式”，我们给予了完整而详细的介绍。根据存在必有其意义的想法，其他的混合编程方式一定有其存在的意义。那么其他方式是怎么实现的，有没有优点，接下来的章节会继续探讨。
8.附录

// matrix.h: interface for the matrix class and
matrix-related functions.

// 头文件

//////////////////////////////////////////////////////////////////////

#ifndef MATRIX_H_H

#define MATRIX_H_H

//封装了与matlab com进行交互的数据。可以把所有matlab的函数的输入参数和返回值看成是矩阵形式。

//作者：张坤

//时间：2013.06.06

class matrix

{

public:

//Dim1：一维数组，表示向量；Dim2：二维数组，表示矩阵。将标量看成是只有一个元素的向量或者矩阵。

enum ArrayType{Dim1,
Dim2};

struct Size

{

int
m_nRows;
//矩阵的行数

int
m_nCols;
//矩阵的列数

Size() : m_nRows(0),
m_nCols(0){ }

Size(int nRows, int nCols) :
m_nRows(nRows), m_nCols(nCols){ }

};

public:

matrix();

matrix(int nRows, int nCols);
//构造nRows行、nCols列的矩阵，所有元素初始化为0

//构造nRows行、nCols列的矩阵，所有元素初始化为一维数组或二维数组的内容

matrix(int nRows, int nCols, double* pdArray,
ArrayType arrType);

matrix(const VARIANT&
var); //用VARIANT构造

matrix(const matrix& other);
//拷贝构造函数，允许使用matrix对象构造

void setMatrix(int nRows, int nCols, double*
pdArray, ArrayType arrType); //设置矩阵的大小和数据

void setMatirx(const VARIANT&
var); //用VARIANT设置矩阵

void setSize(int nRows, int
nCols); //设置矩阵的大小，默认构造后再设置数据

void setData(double* pdArray, ArrayType
arrType); //默认构造后再设置数据

Size
getSize(); //返回矩阵的大小

void getData(double* pdArray, ArrayType
arrType); //获得矩阵的数据

public: //matrix 与 VARIANT的转换

operator VARIANT()
//类型转换运算符,允许在函数的输入参数中使用VARIANT的地方使用matrix

{
//matlab com的接口函数的输入参数都是VARIANT型的变量

return m_varMatrix;

}

VARIANT*
operator&()
//取地址运算符重载，允许在函数的输出参数中使用VARIANT的地方使用matrix

{
//matlab com的接口函数的输出参数都是VARIANT型的变量的指针(取地址)

return
&m_varMatrix;

}

matrix& operator=(const
matrix& other);
//重载赋值运算符,允许matrix之间相互赋值

virtual ~matrix();

private: //注意：私有函数不属于类的接口，属于类的实现部分

Size
m_matrixSize;
//矩阵的大小，包括行和列

VARIANT m_varMatrix; //变体类型，与matlab的接口

//私有函数，将nRow行、nCols列的pdin矩阵转置成pdout矩阵

inline void transpose(int nRows, int nCols,
double* pdin, double* pdout);

inline void copy(const matrix&
other); //复制other到this对象

inline void getVariantSize(Size&
varSize, const VARIANT& var); //获得该var的大小

};

#endif

// matrix.cpp: implementation of the matrix
class.

//源文件

//////////////////////////////////////////////////////////////////////

#include "stdafx.h"

#include "matrix.h"

// 功能：构造0行、0列的空矩阵

// 输入：无

// 输出：无

// 影响：matrix为空矩阵

// 作者：张坤

// 时间：2013.06.06

matrix::matrix()

{

VariantInit(&m_varMatrix);
//一定要初始化

}

// 功能：析构

// 输入：无

// 输出：无

// 影响：无

// 作者：张坤

// 时间：2013.06.06

matrix::~matrix()

{

VariantClear(&m_varMatrix);

}

// 功能：构造nRows行、nCols列的矩阵，所有元素初始化为0

// 输入：nRows, 矩阵的行数; nCols，矩阵的列数

// 输出：无

// 影响：matrix所有元素初始化为0

// 作者：张坤

// 时间：2013.06.06

matrix::matrix(int nRows, int nCols)

{

setSize(nRows, nCols);

}

// 功能：拷贝构造函数，允许使用matrix构造

// 输入：matrix对象

// 输出：无

// 影响：matrix大小和所有元素与输入参数相同

// 作者：张坤

// 时间：2013.06.06

matrix::matrix(const matrix& other)

{

copy(other);

}

// 功能：重载赋值运算符,允许matrix之间相互赋值

// 输入：matrix对象

// 输出：无

// 影响：matrix大小和所有元素与输入参数相同

// 作者：张坤

// 时间：2013.06.06

matrix& matrix::operator=(const
matrix& other)

{

if (this == &other )
//判断是否自身赋值给自身

{

return *this;

}

else

{

copy(other);

return *this;

}

}

// 功能：拷贝另一个matrix对象到this对象

// 输入：matrix对象

// 输出：无

// 影响：matrix大小和所有元素与输入参数相同

// 作者：张坤

// 时间：2013.06.06

void matrix::copy(const matrix& other)

{

m_matrixSize.m_nRows =
other.m_matrixSize.m_nRows;

m_matrixSize.m_nCols =
other.m_matrixSize.m_nCols;

VariantCopy(&m_varMatrix,
(VARIANT*)&other.m_varMatrix);

}

// 功能：用指定的var构造矩阵

// 输入：var：VARIANT型的数据

// 输出：无

// 影响：将matrix的大小和所有元素初始化为var的大小和元素

// 作者：张坤

// 时间：2013.06.12

matrix::matrix(const VARIANT& var)

{

setMatirx(var);

}

// 功能：构造nRows行、nCols列的矩阵，所有元素初始化为一维数组或二维数组的内容

// 输入：nRows, 矩阵的行数; nCols，矩阵的列数，pdArray一维数组或二维数组强制转换的结果，

// arrType，一维数组或二维数组的标识

// 输出：无

// 影响：matrix所有元素初始化为一维数组或二维数组的内容

// 注意：如果matrix表示一个向量，使用一维数组构造，arrType设为matrix::Dim1

//
若干matrix表示一个矩阵，使用二维数组构造，arrType设为matrix::Dim2

// 作者：张坤

// 时间：2013.06.06

matrix::matrix(int nRows, int nCols, double* pdArray, ArrayType
arrType)

:
m_matrixSize(nRows, nCols)

{

setMatrix(nRows, nCols, pdArray, arrType);

}

// 功能：设置nRows行、nCols列的矩阵，元素为一维数组或二维数组的内容

// 输入：nRows, 矩阵的行数; nCols，矩阵的列数，pdArray一维数组或二维数组强制转换的结果，

// arrType，一维数组或二维数组的标识

// 输出：无

// 影响：matrix所有元素初始化为一维数组或二维数组的内容

// 注意：如果matrix表示一个向量，使用一维数组构造，arrType设为matrix::Dim1

//
若干matrix表示一个矩阵，使用二维数组构造，arrType设为matrix::Dim2

// 作者：张坤

// 时间：2013.06.06

void matrix::setMatrix(int nRows, int nCols, double* pdArray,
ArrayType arrType) //默认构造后再设置数据

{

setSize(nRows, nCols);

setData(pdArray, arrType);

}

// 功能：获得指定var的大小

// 输入：varSize引用：var的大小，是返回值；var:欲获得大小的VARIANT

// 输出：无

// 影响：无

// 作者：张坤

// 时间：2013.06.12

void matrix::getVariantSize(Size& varSize, const
VARIANT& var) //获得该var的大小

{

//var是标量

if (var.vt == VT_R8)

{

varSize.m_nRows = 1;

varSize.m_nCols = 1;

}

else if (var.vt == (VT_R8|VT_ARRAY)

&&
var.parray->cDims == 1)
//一维数组，相当于列向量

{

varSize.m_nRows = 1;

varSize.m_nCols =
var.parray->rgsabound[0].cElements;

}

else //二维数组，矩阵

{

varSize.m_nRows =
var.parray->rgsabound[1].cElements;

varSize.m_nCols =
var.parray->rgsabound[0].cElements;

}

}

// 功能：用指定的var设定矩阵

// 输入：var：VARIANT型的数据

// 输出：无

// 影响：将matrix的大小和所有元素设置为var的大小和元素

// 作者：张坤

// 时间：2013.06.12

void matrix::setMatirx(const VARIANT& var)
//用VARIANT设置矩阵

{

getVariantSize(m_matrixSize, var);

VariantCopy(&m_varMatrix,
(VARIANT*)&var);

}

// 功能：设置矩阵的所有元素为一维数组或二维数组的内容

// 输入：nRows, 矩阵的行数; nCols，矩阵的列数

// 输出：无

// 影响：matrix为空，只是定义了大小，必须之后再调用setData()

// 注意：这里用一维数组构造时，形参的格式必须按照列优先的顺序构造。

// 作者：张坤

// 时间：2013.06.06

void matrix::setSize(int nRows, int nCols)
//默认构造后再设置数据

{

m_matrixSize.m_nRows = nRows;

m_matrixSize.m_nCols = nCols;

SAFEARRAYBOUND rgsabound[2]; //2 dim array
二维数组的标识

rgsabound[0].lLbound =
0;
//初始下标从0开始

rgsabound[0].cElements =
m_matrixSize.m_nRows; //1st dim size 第一维的大小

rgsabound[1].lLbound =
0;
//初始下标从0开始

rgsabound[1].cElements =
m_matrixSize.m_nCols; //2nd dim size 第二维的大小

m_varMatrix.vt =
VT_R8|VT_ARRAY;
//double型的二维数组类型的声明

m_varMatrix.parray = SafeArrayCreate(VT_R8, 2,
rgsabound); //double型的二维数组数据的声明

//初始化为全0

double* pdBuf = NULL;
//指针用来指向m_varMatrix.parray的数据区

::SafeArrayAccessData(m_varMatrix.parray, (void
**)&pdBuf);

memset((void*)pdBuf, 0,
m_matrixSize.m_nRows*m_matrixSize.m_nCols*sizeof(double));
//直接设置数据区为全0，也可用循环实现

::SafeArrayUnaccessData(m_varMatrix.parray);

}

// 功能：设置矩阵的所有元素为一维数组或二维数组的内容

// 输入：pdArray一维数组或二维数组强制转换的结果，

// arrType，一维数组或二维数组的标识

// 输出：无

// 影响：matrix所有元素设置为一维数组或二维数组的内容

// 注意：这里用一维数组构造时，形参的格式必须按照列优先的顺序构造。

// 作者：张坤

// 时间：2013.06.06

void matrix::setData(double* pdArray, ArrayType
arrType) //默认构造后再设置数据

{

double* pdBuf = NULL;
//指针用来指向m_varMatrix.parray的数据区

::SafeArrayAccessData(m_varMatrix.parray, (void
**)&pdBuf);

if (arrType ==
Dim1) //这里一定要注意pdArray
是存储矩阵元素的一维数组，其排列顺序必须是列优先的。

{

memcpy((void*)pdBuf, pdArray,
m_matrixSize.m_nRows*m_matrixSize.m_nCols*sizeof(double));
//直接赋值pdArray指向的数据区

}

else // arrType == Dim2

{

//由于C++二维数组是按行优先顺序来存储的，所以需要转置为列优先的顺序。

transpose(m_matrixSize.m_nRows,
m_matrixSize.m_nCols, pdArray, pdBuf);

}

::SafeArrayUnaccessData(m_varMatrix.parray);

}

// 功能：获得矩阵的数据, 返回值矩阵可以为一维数组或二维数组

// 输入：pdArray一维数组或二维数组强制转换的结果，

// arrType，一维数组或二维数组的标识

// 输出：无

// 影响：无

// 注意：这里用一维数组构造时，形参的格式是按照列优先的顺序排列的。

// 作者：张坤

// 时间：2013.06.07

void matrix::getData(double* pdArray, ArrayType
arrType) //获得矩阵的数据

{

getSize(); //获取数组的大小

if (m_varMatrix.vt == VT_R8)
//特殊情况，标量值，不是VT_R8|VT_ARRAY

{

pdArray[0] =
m_varMatrix.dblVal;

return;

} //特殊情况处理结束

double* pdBuf = NULL;

::SafeArrayAccessData(m_varMatrix.parray, (void
**)&pdBuf);

if (arrType == Dim1)

{

memcpy(pdArray, pdBuf,
m_matrixSize.m_nRows*m_matrixSize.m_nCols*sizeof(double));

}

else //arrType == Dim2

{
//从列优先的存储转换为行优先的存储

transpose(m_matrixSize.m_nCols,
m_matrixSize.m_nRows, pdBuf, pdArray);

}

::SafeArrayUnaccessData(m_varMatrix.parray);

}

// 功能：获得矩阵的维数

// 输入：pdArray一维数组或二维数组强制转换的结果，

// arrType，一维数组或二维数组的标识

// 输出：无

// 影响：无

// 注意：这里用一维数组构造时，形参的格式是按照列优先的顺序排列的。

// 作者：张坤

// 时间：2013.06.07

matrix::Size matrix::getSize()

{

//若还未获取作为返回值的matrix封装的m_varMatrix的大小，获取之

if (m_matrixSize.m_nRows == 0 ||
m_matrixSize.m_nCols == 0)

{

getVariantSize(m_matrixSize,
m_varMatrix);

}

//已经获取作为返回值的matrix封装的m_varMatrix的大小，或者是作为输入变量的matrix。

//直接返回m_matrixSize

return m_matrixSize;

}

// 功能：将nRow行、nCols列的pdin矩阵转置成pdout矩阵

// 输入：pdin待转置的矩阵，nRows、nCols为pdin的行数和列数

// pdout为转置的结果,
pdout为nCols行、nRows列.

// 输出：无

// 影响：无

// 注意：该函数可以实现行优先与列优先访问时的数据变换，在getData，setData

// 和构造函数中使用。

// 作者：张坤

// 时间：2013.06.11

void matrix::transpose(int nRows, int nCols, double* pdin,
double* pdout)

{

for (int i = 0; i < nRows;
++i) //第i行

{

for (int j = 0; j
< nCols; ++j)//第j列

{

pdout[j*nRows
+ i] = pdin[i*nCols + j];

}

}

}



本文是作者原创，转载必须保证文章的完整性并标明出处（blog.sina.com.cn/zhangkunhn），请尊重作者，支持原创。