ExcelのVBAで使えるDLLを、C++（Visual Studio 2017）で作る。・・・その４．２（配列編）

初めに

前回は、予定を変更して、String型の受け渡しをする方法についてまとめました。

今回は、SAFEARRAYについてどのようなものか調べた前々回の続編です。
実際に配列データの受け渡しを行います。

SAFEARRAYに関する追加情報

配列要素のデータ型

前回の記事で、気が付いた人もいるかもしれないが、SAFEARRAY構造体のメンバーには配列要素の型情報がない。
fFeatures に、VARIANT型およびBSTR型の場合に立つフラグがあるが、それ以外の型の場合、構造体メンバーだけでは判断ができない。

これについては、後述する型判定関数があるので、基本的な型であれば問題ない。

引数

VBAでは、配列はByValでは引数に指定できないので、ByRef指定となる。
そのため、DLL側では、SAFEARRAYの受け渡しをするために、引数は、
SAFEARRAYを指すポインタ（SAFEARRAY*）ではなく、
SAFEARRAYを指すポインタへのポインタ（SAFEARRAY**）とする。

一方、呼び出すVBA側では、Declare で受け渡しをする引数をどの様に書けばいいのか？
VBAには、SAFEARRYなるデータ型はない。
結論から言えば、通常のプロシージャと同様で、下記のようになる。

Declare Sub 関数名 Lib "DLL名" (ByRef 配列変数名() As データ型)

As Byteだろうが
As Longだろうが
As Variantだろうが
構わない。

言い換えれば、下記のように、Declare でAlias を設定すれば、DLLのひとつの関数で異なるデータ型の受け渡しも可能となる。
DLLの関数宣言

__declspec(dllexport) void WINAPI FuncX(LPSAFEARRAY* ppsa);

VBA側の宣言
上記のDLLの関数宣言に対し、以下の宣言は、いずれも問題ない。

Declare Sub XByte Lib "DLL名" Alias "FuncX" (ByRef 配列変数名() As Byte)
Declare Sub XLong Lib "DLL名" Alias "FuncX" (ByRef 配列変数名() As Long)
Declare Sub XVariant Lib "DLL名" Alias "FuncX" (ByRef 配列変数名() As Variant)

主な処理と使用する関数

HRESULTを返す関数の成否判定

いくつかの関数は復帰値の型が、HRESULTとなっている。
これらの関数は、成功すると S_OK （0x00000000）を返す。
成功を判定するマクロとして、SUCCEEDED マクロがあり、
失敗を判定するマクロとして、FAILED マクロがあるので、必要に応じて使えばよい。

使用例

HRESULT hResult = SafeArrayAccessData(*ppsa, (void**)&piValue);

if (FAILED(hResult))
    return;

HRESULT が取る値（抜粋？）については、こちらに記載されている。

SAFEARRAYに格納されている要素のデータ型分類値の取得

SafeArrayGetVartype

HRESULT SafeArrayGetVartype(
  SAFEARRAY *psa,
  VARTYPE   *pvt
);

VBAから渡した場合、VERTYPEは、以下のような値を取る。

項目	データ型		値	備考
	VBA	C++
VT_I2	Integer	short	0x0002
VT_I4	Long	int	0x0003
VT_R4	Single	float	0x0004
VT_R8	Double	double	0x0005
VT_CY	Currency	CY	0x0006
VT_DATE	Date	DATE	0x0007
VT_BSTR	String	BSTR	0x0008
VT_BOOL	Boolean	BOOL	0x00B
VT_VARIANT	Variant	VARIANT	0x00C
VT_UI1	Byte	unsigned char	0x0011
VT_I8	LongLong	long long	0x0014	64bit版のみ

docs.microsoft.com

配列の次元数の取得

SafeArrayGetDim

UINT SafeArrayGetDim(
  SAFEARRAY *psa
);

docs.microsoft.com

配列の１要素のサイズの取得

SafeArrayGetElemsize

UINT SafeArrayGetElemsize(
  SAFEARRAY *psa
);

例えば、VBA側で、

Dim arryL(2) As Long
Dim arryV(2) As Variant
Dim arryS(2) As String

と宣言されていた場合、
arryLは、Longのサイズになるので、4 (Byte)が返る。
arryVは、Variantのサイズになるので、16 (Byte)が返る。
arrySは、Stringのポインタサイズ（？）になるので、4 (Byte)が返る。

docs.microsoft.com

指定した次元のインデックスの指定可能最小値(LBound)の取得

SafeArrayGetLBound

HRESULT SafeArrayGetLBound(
  SAFEARRAY *psa,
  UINT      nDim,
  LONG      *plLbound
);

nDim は、対象となる次元。
左端の次元が１となり、右に行くと増えていく。
指定方法が、SAFEARRAY メンバーの rgsabound[n].lLbound とは異なるので、何らかの理由で両関数を使い分ける必要がある場合には注意が必要。

Dim arryL(1 To 2, 3 To 5) As Long

の場合、

nDim	Lbound
1	1
2	3

となる。

SAFEARRAYのメンバー、rgsabound[n].lLbound を参照して取得する方法もある。
指定方法は、前回のrgsaboundの説明を参照。
SafeArrayGetLBound の方が、直感的に指定しやすい。

docs.microsoft.com

指定した次元のインデックスの指定可能最大値(UBound)の取得

SafeArrayGetUBound

HRESULT SafeArrayGetUBound(
  SAFEARRAY *psa,
  UINT      nDim,
  LONG      *plUbound
);

SafeArrayGetLBound と同様。

こちらは、SAFEARRAYに直接取得できるメンバーはない。
rgsabound[n].lLbound + rgsabound[n].cElements - 1
で計算はできる。

docs.microsoft.com

配列のロックカウントをインクリメントと、配列データへのポインターの取得

SafeArrayAccessData

HRESULT SafeArrayAccessData(
  SAFEARRAY  *psa,
  void HUGEP **ppvData
);

ポインタを使って、要素にアクセスする場合に使用するものらしい。
配列データへのポインタを返すのと同時に、SafeArrayへのロックを行う。

SAFEARRAY ppvData 使用後、SafeArrayUnaccessData を呼び出さなければいけない。

SafeArrayGetElement および SafeArrayPutElement を使用するよりも高速に処理ができるらしい。

This approach is faster than using SafeArrayGetElement and SafeArrayPutElement.

https://docs.microsoft.com/ja-jp/windows/win32/api/oleauto/nf-oleauto-safearrayaccessdata?f1url=https%3A%2F%2Fmsdn.microsoft.com%2Fquery%2Fdev15.query%3FappId%3DDev15IDEF1%26l%3DJA-JP%26k%3Dk(OLEAUTO%2FSafeArrayAccessData)%3Bk(SafeArrayAccessData)%3Bk(DevLang-C%2B%2B)%3Bk(TargetOS-Windows)%26rd%3Dtrue#examples

多次元配列の場合、前回の記事に記載の通り、ポインタのインクリメントと配列のインデックスに注意が必要。

HUGEP は正直なところ、よくわかっていない。
１６bit時代（？）に使われていたみたいだが・・・
省略して、単に void** にキャストしても、データは取得できた。
とりあえず、使わない方向で行くことに・・・

docs.microsoft.com

配列のロックカウントをデクリメントと、SafeArrayAccessDataによって取得されたポインターの無効化

SafeArrayUnaccessData

HRESULT SafeArrayUnaccessData(
  SAFEARRAY *psa
);

SafeArrayAccessData によりロックした配列のアンロックを行う。

docs.microsoft.com

配列記述子と配列内のすべてのデータの破棄

SafeArrayDestroy

HRESULT SafeArrayDestroy(
  SAFEARRAY *psa
);

配列の単一の要素の取得

SafeArrayGetElement

HRESULT SafeArrayGetElement(
  SAFEARRAY *psa,
  LONG      *rgIndices,
  void      *pv
);

rgIndices

配列の各次元のインデックスのベクトル。
右端（最下位）の次元はrgIndices [0]
左端の次元は、rgIndices [psa-> cDims – 1]

２次元以上の配列の場合、要素数が配列の次元数のlong型の配列を用意して、
取得したい要素の各次元のインデックスを格納して、関数に渡す。

Dim  arry(3, 3, 3) As Long

という配列があり、arry(1, 2, 3) の要素を取得したい場合には、以下のようにすればよい。

long  lIndex[] = {1, 2, 3};
int iValue;
SafeArrayGetElement(*ppsa, lIndex, &iValue);

pv

取得した要素を格納する変数

docs.microsoft.com

データ要素を配列内の指定された場所に保存

SafeArrayPutElement

HRESULT SafeArrayPutElement(
  SAFEARRAY *psa,
  LONG      *rgIndices,
  void      *pv
);

使い方は、SafeArrayGetElementと同様。（pvは、書き込むデータ）

long lValue = getSomeValue();
SafeArrayPutElement(*ppsa, &lIndex, &lValue);

ただし、BSTRの場合は注意が必要。

BSTR bstr;
bstr = SysAllocStringByteLen(pszReturn, lenByte);
//&bstrではないので注意！！！(& は不要)
SafeArrayPutElement(*ppsa, &lIndex, bstr);

docs.microsoft.com

配列内のすべてのデータの破棄

SafeArrayDestroy

HRESULT SafeArrayDestroy(
  SAFEARRAY *psa
);

既存の配列記述子と配列内のすべてのデータを破棄します。オブジェクトが配列に格納されている場合、配列内の各オブジェクトでReleaseが呼び出されます。
docs.microsoft.com

VBAからDLLへ渡す

VBAから渡された配列の値を、メッセージボックスで表示してみました。

処理の流れ

1. 格納されているデータ型の確認
2. 配列の次元数の確認
3. 各次元の要素数、インデックスの上下限の確認
4. データ読み込み
5. 後処理

DLLからVBAへ返す

VBAから受け取った配列に、何らかの値を格納して返してみました。

処理の流れ

1. 格納されているデータ型の確認
2. 配列の次元数の確認
3. 各次元の要素数、インデックスの上下限の確認
4. データ書き込み
5. 後処理

コード

DLL

AccessibleFromVBA.h

▶クリックで展開

extern "C"
{
#define ACCESSIBLEFROMVBA_API __declspec(dllexport) 

	ACCESSIBLEFROMVBA_API void WINAPI DoNothing();
	ACCESSIBLEFROMVBA_API int  WINAPI GetNumberI(int i);
	ACCESSIBLEFROMVBA_API void WINAPI GetNumberI2(int* pi);

	ACCESSIBLEFROMVBA_API void WINAPI SetString(VARIANT vString);
	ACCESSIBLEFROMVBA_API void WINAPI SetStringS(const BSTR sString);

	ACCESSIBLEFROMVBA_API void WINAPI GetStringByParam(VARIANT* pvString);
	ACCESSIBLEFROMVBA_API void WINAPI GetStringByParamS(BSTR* pbstr);
	ACCESSIBLEFROMVBA_API VARIANT WINAPI GetStringByRetVal();
	ACCESSIBLEFROMVBA_API BSTR WINAPI GetStringByRetValS();

	ACCESSIBLEFROMVBA_API void WINAPI SetArrayGE(const LPSAFEARRAY* ppsa);
	ACCESSIBLEFROMVBA_API void WINAPI SetArrayAD(const LPSAFEARRAY* ppsa);

	ACCESSIBLEFROMVBA_API void WINAPI GetArrayPE(LPSAFEARRAY* ppsa);
	ACCESSIBLEFROMVBA_API void WINAPI GetArrayAD(LPSAFEARRAY* ppsa);
}

AccessibleFromVBA.cpp

追加部分のみ

プロトタイプ宣言

std::wstring	convMbc2Wstr(const char* lpcszSrc);
std::wstring	convMbcBstr2Wstr(const BSTR& bstr);

DLLに配列を渡す処理

▶クリックで展開

• GE：SafeArrayGetElementを使用して読み込む処理
• AD：SafeArrayAccessDataで取得したポインタを使用して読み込む処理

ACCESSIBLEFROMVBA_API void WINAPI SetArrayGE(const LPSAFEARRAY* ppsa)
{
    //格納されているデータ型の確認
    VARTYPE vt;
    HRESULT hResult = SafeArrayGetVartype(*ppsa, &vt);

    if (FAILED(hResult))
    {
        //VARIANTに格納できない（？）データの配列の場合、この判定ではNG
        return;
    }

    //次元数
    UINT uiDims = SafeArrayGetDim(*ppsa);

    std::wstringstream ss;

    for (UINT i = 1; i <= uiDims; ++i)
    {
        LONG lLBound, lUBound;
        hResult = SafeArrayGetLBound(*ppsa, i, &lLBound);
        hResult = SafeArrayGetUBound(*ppsa, i, &lUBound);

        ss << i << L"次元\n"
            << L"　LBound：" << lLBound << L"\n"
            << L"　UBound：" << lUBound << L"\n";
    }

    if (vt == VT_I4)
    {
        ss << L"データ型：Long\n";

        if (uiDims == 2)
        {
            LONG lIndex[2];

            LONG lLBound[2];
            LONG lUBound[2];

            hResult = SafeArrayGetLBound(*ppsa, 1, &lLBound[0]);
            hResult = SafeArrayGetUBound(*ppsa, 1, &lUBound[0]);

            for (LONG i = lLBound[0]; i <= lUBound[0]; ++i)
            {
                hResult = SafeArrayGetLBound(*ppsa, 2, &lLBound[1]);
                hResult = SafeArrayGetUBound(*ppsa, 2, &lUBound[1]);

                lIndex[0] = i;

                for (LONG j = lLBound[1]; j <= lUBound[1]; ++j)
                {
                    lIndex[1] = j;

                    int iValue;
                    hResult = SafeArrayGetElement(*ppsa, lIndex, &iValue);

                    ss << iValue << L"\n";
                }
            }
        }
    }
    else if (vt == VT_BSTR)
    {
        ss << L"データ型：String\n";

        if (uiDims == 1)
        {
            LONG lLBound;
            LONG lUBound;

            hResult = SafeArrayGetLBound(*ppsa, 1, &lLBound);
            hResult = SafeArrayGetUBound(*ppsa, 1, &lUBound);

            for (LONG lIndex = lLBound; lIndex <= lUBound; ++lIndex)
            {
                BSTR bstr;

                SafeArrayGetElement(*ppsa, &lIndex, &bstr);

                ss << convMbcBstr2Wstr(bstr) << L"\n";

                SysFreeString(bstr);
            }
        }
    }
    else if (vt == VT_VARIANT)
    {
        ss << L"データ型：Variant\n";

        if (uiDims == 1)
        {
            LONG lLBound;
            LONG lUBound;

            hResult = SafeArrayGetLBound(*ppsa, 1, &lLBound);
            hResult = SafeArrayGetUBound(*ppsa, 1, &lUBound);

            for (LONG lIndex = lLBound; lIndex <= lUBound; ++lIndex)
            {
                VARIANT vValue;
                VariantInit(&vValue);
                hResult = SafeArrayGetElement(*ppsa, &lIndex, &vValue);

                switch (vValue.vt)
                {
                case VT_I4:
                    ss << std::to_wstring(vValue.intVal) << L"\n";
                    break;
                case VT_R8:
                    ss << std::to_wstring(vValue.dblVal) << L"\n";
                    break;
                case VT_BSTR:
                    ss << vValue.bstrVal << L"\n";
                    break;
                case VT_BSTR | VT_BYREF:
                    ss << vValue.pbstrVal << L"\n";
                    break;
                default:
                    break;
                } ;

                VariantClear(&vValue);
            }
        }

    }
    else
    {
        MessageBox(NULL, L"No Data Type matched.", L"SetArrayGE", MB_OK | MB_ICONINFORMATION);

        return;
    }

    MessageBox(NULL, ss.str().c_str(), L"SetArrayGE", MB_OK | MB_ICONINFORMATION);

    return;
}

ACCESSIBLEFROMVBA_API void WINAPI SetArrayAD(const LPSAFEARRAY* ppsa)
{
    //格納されているデータ型の確認
    VARTYPE vt;
    HRESULT hResult = SafeArrayGetVartype(*ppsa, &vt);

    if (FAILED(hResult))
    {
        //VARIANTに格納できない（？）データの配列の場合、この判定ではNG
        return;
    }

    //次元数
    UINT uiDims = SafeArrayGetDim(*ppsa);

    std::wstringstream ss;

    for (UINT i = 1; i <= uiDims; ++i)
    {
        LONG lLBound, lUBound;
        hResult = SafeArrayGetLBound(*ppsa, i, &lLBound);
        hResult = SafeArrayGetUBound(*ppsa, i, &lUBound);

        ss << i << L"次元\n"
            << L"　LBound：" << lLBound << L"\n"
            << L"　UBound：" << lUBound << L"\n";
    }

    if (vt == VT_I4)
    {
        ss << L"データ型：Long\n";

        //全要素数
        ULONG ulElems(1);
        for (ULONG i = 0; i < uiDims; ++i)
        {
            ulElems *= (*ppsa)->rgsabound[i].cElements;
        }

        int* piValue(0);

        hResult = SafeArrayAccessData(*ppsa, (void**)&piValue);

        for (ULONG i = 0; i < ulElems; ++i)
        {
            ss << L"0x" << std::setfill(L'0') << std::right << std::setw(8) << std::hex << *piValue << L"\n";

            ++piValue;
        }

        hResult = SafeArrayUnaccessData(*ppsa);
    }
    else if (vt == VT_BSTR)
    {
        ss << L"データ型：String\n";

        BSTR* pbstr(0);

        hResult = SafeArrayAccessData(*ppsa, (void**)&pbstr);

        std::wstring ws = convMbcBstr2Wstr(*pbstr);

        for (ULONG i = 0; i < (*ppsa)->rgsabound[0].cElements; ++i)
        {
            ws = convMbcBstr2Wstr(*pbstr);
            ss << ws << L"\n";

            ++pbstr;
        }

        hResult = SafeArrayUnaccessData(*ppsa);
    }
    else if (vt == VT_VARIANT)
    {
        ss << L"データ型：Variant\n";

        VARIANT* pv(0);
        
        hResult = SafeArrayAccessData(*ppsa, (void**)&pv);

        for (ULONG i = 0; i < (*ppsa)->rgsabound[0].cElements; ++i)
        {
            switch (pv->vt)
            {
            case VT_I4:
                ss << std::to_wstring(pv->intVal) << L"\n";
                break;
            case VT_R8:
                ss << std::to_wstring(pv->dblVal) << L"\n";
                break;
            case VT_BSTR:
                ss << convVstr2Wstr(*pv) << L"\n";
                break;
            default:
                break;
            }

            ++pv;
        }

        hResult = SafeArrayUnaccessData(*ppsa);
    }
    else
    {
        MessageBox(NULL, L"No Data Type matched.", L"SetArrayAD", MB_OK | MB_ICONINFORMATION);

        return;
    }

    MessageBox(NULL, ss.str().c_str(), L"SetArrayAD", MB_OK | MB_ICONINFORMATION);

    return;
}

DLLで配列を更新して返す処理

▶クリックで展開

• PE：SafeArrayPutElementを使用して書き換える処理
• AD：SafeArrayAccessDataで取得したポインタを使用して書き換える処理

ACCESSIBLEFROMVBA_API void WINAPI GetArrayPE(LPSAFEARRAY* ppsa)
{
    //格納されているデータ型の確認
    VARTYPE vt;
    HRESULT hResult = SafeArrayGetVartype(*ppsa, &vt);

    if (FAILED(hResult))
    {
        //VARIANTに格納できない（？）データの配列の場合、この判定ではNG
        return;
    }

    //次元数
    UINT uiDims = SafeArrayGetDim(*ppsa);

    LONG* plLBound = new LONG[uiDims];
    LONG* plUBound = new LONG[uiDims];

    for (UINT i = 0; i < uiDims; ++i)
    {
        SafeArrayGetLBound(*ppsa, i + 1, &plLBound[i]);
        SafeArrayGetUBound(*ppsa, i + 1, &plUBound[i]);
    }

    if (vt == VT_I4)
    {
        if (uiDims == 2)
        {
            LONG* plIndex = new LONG[uiDims];

            for (LONG i = plLBound[0]; i <= plUBound[0]; ++i)
            {
                plIndex[0] = i;

                for (LONG j = plLBound[1]; j <= plUBound[1]; ++j)
                {
                    plIndex[1] = j;

                    long lValue;
                    SafeArrayGetElement(*ppsa, plIndex, &lValue);
                    lValue *= 2;
                    SafeArrayPutElement(*ppsa, plIndex, &lValue);
                }
            }
        }
    }
    else if (vt == VT_R8)
    {
        if (uiDims == 1)
        {
            LONG lIndex;

            for (LONG i = plLBound[0]; i <= plUBound[0]; ++i)
            {
                lIndex = i;

                double dValue;
                SafeArrayGetElement(*ppsa, &lIndex, &dValue);
                dValue /= 2.0;
                SafeArrayPutElement(*ppsa, &lIndex, &dValue);
            }
        }
    }
    else if (vt == VT_VARIANT)
    {
        if (uiDims == 1)
        {
            LONG lIndex;

            for (LONG i = plLBound[0]; i <= plUBound[0]; ++i)
            {
                VARIANT vOrg;
                VariantInit(&vOrg);

                lIndex = i;
                SafeArrayGetElement(*ppsa, &lIndex, &vOrg);

                VARIANT vOut;
                VariantInit(&vOut);
                if (vOrg.vt == VT_EMPTY)
                {
                    vOut.vt = VT_BSTR;
                }
                else
                {
                    vOut.vt = vOrg.vt;
                }

                switch (vOrg.vt)
                {
                case VT_I4:
                    vOut.intVal = vOrg.intVal * 2;
                    SafeArrayPutElement(*ppsa, &lIndex, &vOut);
                    break;
                case VT_R8:
                    vOut.dblVal = vOrg.dblVal / 2.0;
                    SafeArrayPutElement(*ppsa, &lIndex, &vOut);
                    break;
                case VT_BSTR:
                {
                    std::wstring ws = L"GetArrayPE";
                    ws += std::to_wstring(lIndex);
                    SysReAllocString(&vOut.bstrVal, ws.c_str());
                    SafeArrayPutElement(*ppsa, &lIndex, &vOut);
                    SysFreeString(vOut.bstrVal);
                }
                    break;
                default:
                    break;
                }

                VariantClear(&vOrg);
                VariantClear(&vOut);
            }
        }
    }
    else if (vt == VT_BSTR)
    {
        if (uiDims == 1)
        {
            LONG lIndex;

            for (LONG i = plLBound[0]; i <= plUBound[0]; ++i)
            {
                lIndex = i;

                std::string sReturn = "GetArrayPE:";
                sReturn += std::to_string(i + 1);
                size_t lenByte = sReturn.length();

                BSTR bstr = SysAllocStringByteLen(sReturn.c_str(), lenByte);
                //&bstrではないので注意！！！(& は不要)
                SafeArrayPutElement(*ppsa, &lIndex, bstr);

                SysFreeString(bstr);
            }
        }
    }
    
    delete[] plLBound;
    delete[] plUBound;

    return;
}

ACCESSIBLEFROMVBA_API void WINAPI GetArrayAD(LPSAFEARRAY* ppsa)
{
    //格納されているデータ型の確認
    VARTYPE vt;
    HRESULT hResult = SafeArrayGetVartype(*ppsa, &vt);

    if (FAILED(hResult))
    {
        //VARIANTに格納できない（？）データの配列の場合、この判定ではNG
        return;
    }

    //次元数
    UINT uiDims = SafeArrayGetDim(*ppsa);

    //全要素数
    ULONG ulElems(1);
    for (ULONG i = 0; i < uiDims; ++i)
    {
        ulElems *= (*ppsa)->rgsabound[i].cElements;
    }

    if (vt == VT_I4)
    {
        int* piValue;
        SafeArrayAccessData(*ppsa, (void**)&piValue);
        for (ULONG i = 0; i < ulElems; ++i)
        {
            *piValue *= 3;

            ++piValue;
        }
        SafeArrayUnaccessData(*ppsa);
    }
    else if (vt == VT_BSTR)
    {
        BSTR* pbstr;
        SafeArrayAccessData(*ppsa, (void**)&pbstr);
        for (ULONG i = 0; i < ulElems; ++i)
        {
            std::string ws("GetArrayAD");
            ws += std::to_string(i);
            UINT lenByte = ws.length();

            SysFreeString(*pbstr);
            *pbstr = SysAllocStringByteLen(ws.c_str(), lenByte);

            ++pbstr;
        }
        SafeArrayUnaccessData(*ppsa);
    }
    else if (vt == VT_VARIANT)
    {
        VARIANT* pv;
        SafeArrayAccessData(*ppsa, (void**)&pv);
        for (ULONG i = 0; i < ulElems; ++i)
        {
            switch (pv->vt)
            {
            case VT_I4:
                pv->intVal *= 4;
                break;
            case VT_EMPTY:
            {
                std::wstring ws(L"GetArrayAD_EMPTY");
                ws += std::to_wstring(i);
                pv->vt = VT_BSTR;
                pv->bstrVal = SysAllocString(ws.c_str());
            }
                break;
            case VT_BSTR:
            {
                std::wstring ws(L"GetArrayAD_BSTR");
                ws += std::to_wstring(i);
                SysReAllocString(&(pv->bstrVal), ws.c_str());
            }
                break;
            default:
                break;
            }

            ++pv;
        }
        SafeArrayUnaccessData(*ppsa);
    }

    return;
}

文字列変換処理

▶クリックで展開

std::wstring    convMbc2Wstr(const char* lpcszSrc)
{
    if (!lpcszSrc)
    {
        return std::wstring(L"");
    }

    //必要なバッファサイズ取得

    /*
    cbMultiByte（第４引数）
    lpMultiByteStrパラメーターで示される文字列のサイズ（バイト単位）。 
    または、文字列がヌルで終了する場合、このパラメーターを-1に設定できます。 
    cbMultiByteが0の場合、関数は失敗することに注意してください。
    
    このパラメーターが-1の場合、関数は終端のヌル文字を含む入力文字列全体を処理します。 
    したがって、結果のUnicode文字列には終端のヌル文字が含まれ、
    関数によって返される長さにはこの文字が含まれます。

    このパラメーターが正の整数に設定されている場合、
    関数は指定されたバイト数を正確に処理します。 
    指定されたサイズに終端のヌル文字が含まれていない場合、
    結果のUnicode文字列はヌル終端されず、
    返される長さにはこの文字は含まれません。 
    */
    int iNeedBufferElems = MultiByteToWideChar(CP_ACP, 0, lpcszSrc, -1, nullptr, 0);

    wchar_t* pwsz = new wchar_t[iNeedBufferElems];

    int iResult = MultiByteToWideChar(CP_ACP, 0, lpcszSrc, -1, pwsz, iNeedBufferElems);

    std::wstring ws(pwsz);

    delete[] pwsz;

    return ws;
}

std::wstring    convMbcBstr2Wstr(const BSTR& bstr)
{
    return convMbc2Wstr((const char*)bstr);
}

AccessibleFromVBA.def

▶クリックで展開

LIBRARY AccessibleFromVba

EXPORTS
    DoNothing
    GetNumberI
    GetNumberI2
    SetString
    SetStringS
    GetStringByParam
    GetStringByParamS
    GetStringByRetVal
    GetStringByRetValS
    SetArrayGE
    SetArrayAD
    GetArrayPE
    GetArrayAD

VBA

▶クリックで展開

Private Declare Sub getArrayPEL Lib "C:\Datas\MyDatas\Developer\VisualStudioComunity2017\DllForVBA\AccessibleFromVBA\Debug\AccessibleFromVBA.dll" Alias "GetArrayPE" (ByRef lArray() As Long)
Private Declare Sub getArrayPES Lib "C:\Datas\MyDatas\Developer\VisualStudioComunity2017\DllForVBA\AccessibleFromVBA\Debug\AccessibleFromVBA.dll" Alias "GetArrayPE" (ByRef sArray() As String)
Private Declare Sub getArrayPEV Lib "C:\Datas\MyDatas\Developer\VisualStudioComunity2017\DllForVBA\AccessibleFromVBA\Debug\AccessibleFromVBA.dll" Alias "GetArrayPE" (ByRef vArray() As Variant)

Private Declare Sub getArrayADL Lib "C:\Datas\MyDatas\Developer\VisualStudioComunity2017\DllForVBA\AccessibleFromVBA\Debug\AccessibleFromVBA.dll" Alias "GetArrayAD" (ByRef lArray() As Long)
Private Declare Sub getArrayADS Lib "C:\Datas\MyDatas\Developer\VisualStudioComunity2017\DllForVBA\AccessibleFromVBA\Debug\AccessibleFromVBA.dll" Alias "GetArrayAD" (ByRef sArray() As String)
Private Declare Sub getArrayADV Lib "C:\Datas\MyDatas\Developer\VisualStudioComunity2017\DllForVBA\AccessibleFromVBA\Debug\AccessibleFromVBA.dll" Alias "GetArrayAD" (ByRef vArray() As Variant)



Private Declare Sub setArrayGEL Lib "C:\Datas\MyDatas\Developer\VisualStudioComunity2017\DllForVBA\AccessibleFromVBA\Debug\AccessibleFromVBA.dll" Alias "SetArrayGE" (ByRef lArray() As Long)
Private Declare Sub setArrayGES Lib "C:\Datas\MyDatas\Developer\VisualStudioComunity2017\DllForVBA\AccessibleFromVBA\Debug\AccessibleFromVBA.dll" Alias "SetArrayGE" (ByRef sArray() As String)
Private Declare Sub setArrayGED Lib "C:\Datas\MyDatas\Developer\VisualStudioComunity2017\DllForVBA\AccessibleFromVBA\Debug\AccessibleFromVBA.dll" Alias "SetArrayGE" (ByRef dArray() As Double)
Private Declare Sub setArrayGEV Lib "C:\Datas\MyDatas\Developer\VisualStudioComunity2017\DllForVBA\AccessibleFromVBA\Debug\AccessibleFromVBA.dll" Alias "SetArrayGE" (ByRef vArray() As Variant)

Private Declare Sub setArrayADL Lib "C:\Datas\MyDatas\Developer\VisualStudioComunity2017\DllForVBA\AccessibleFromVBA\Debug\AccessibleFromVBA.dll" Alias "SetArrayAD" (ByRef lArray() As Long)
Private Declare Sub setArrayADS Lib "C:\Datas\MyDatas\Developer\VisualStudioComunity2017\DllForVBA\AccessibleFromVBA\Debug\AccessibleFromVBA.dll" Alias "SetArrayAD" (ByRef sArray() As String)
Private Declare Sub setArrayADD Lib "C:\Datas\MyDatas\Developer\VisualStudioComunity2017\DllForVBA\AccessibleFromVBA\Debug\AccessibleFromVBA.dll" Alias "SetArrayAD" (ByRef dArray() As Double)
Private Declare Sub setArrayADV Lib "C:\Datas\MyDatas\Developer\VisualStudioComunity2017\DllForVBA\AccessibleFromVBA\Debug\AccessibleFromVBA.dll" Alias "SetArrayAD" (ByRef vArray() As Variant)

Public Sub getArrayADTest()

    Dim lArray(2 To 5, 3 To 4)  As Long
    Dim sArray(2 To 6)   As String
    Dim vArray(3)   As Variant
    Dim i           As Long
    Dim j           As Long

    For i = LBound(lArray, 1) To UBound(lArray, 1)
        For j = LBound(lArray, 2) To UBound(lArray, 2)
            lArray(i, j) = i * &H10 + j
            Debug.Print i, j, "0x" & Hex(lArray(i, j))
        Next j
    Next i

    Debug.Print ""

    Call getArrayADL(lArray)

    For i = LBound(lArray, 1) To UBound(lArray, 1)
        For j = LBound(lArray, 2) To UBound(lArray, 2)
            Debug.Print i, j, "0x" & Hex(lArray(i, j))
        Next j
    Next i

    Debug.Print ""

    Call getArrayADS(sArray)

    For i = LBound(sArray) To UBound(sArray)
        Debug.Print sArray(i)
    Next i

    Debug.Print ""

    vArray(0) = ""
    vArray(1) = 1&

    Call getArrayADV(vArray)

    For i = LBound(vArray) To UBound(vArray)
        Debug.Print vArray(i)
    Next i

End Sub

Public Sub getArrayPETest()

    Dim lArray(2 To 5, 3 To 4)  As Long
    Dim sArray(4)   As String
    Dim vArray(3)   As Variant
    Dim i           As Long
    Dim j           As Long

    For i = LBound(lArray, 1) To UBound(lArray, 1)
        For j = LBound(lArray, 2) To UBound(lArray, 2)
            lArray(i, j) = i * 100 + j
        Next j
    Next i

    Call getArrayPEL(lArray)

    For i = LBound(lArray, 1) To UBound(lArray, 1)
        For j = LBound(lArray, 2) To UBound(lArray, 2)
            Debug.Print i, j, lArray(i, j)
        Next j
    Next i

    Call getArrayPEV(vArray)

    For i = LBound(vArray) To UBound(vArray)
        Debug.Print vArray(i)
    Next i


    Call getArrayPES(sArray)

    For i = LBound(sArray) To UBound(sArray)
        Debug.Print sArray(i)
    Next i

End Sub


Public Sub setArrayTest()

    Dim lArray(3 To 8, 1 To 3) As Long
    Dim sArray(2 To 5)  As String
    Dim dArray(4 To 5)  As Double
    Dim vArray(5 To 8)  As Variant
    Dim i           As Long
    Dim j           As Long

    For i = LBound(lArray, 1) To UBound(lArray, 1)
        For j = LBound(lArray, 2) To UBound(lArray, 2)
            lArray(i, j) = i * &H1000 + j * &H10
        Next j
    Next i

    For i = LBound(sArray) To UBound(sArray)
        sArray(i) = String(i, CStr(i))
    Next i

    For i = LBound(dArray) To UBound(dArray)
        If i <> 0 Then
            dArray(i) = 100 / i
        Else
            dArray(i) = -1
        End If
    Next i

    vArray(8) = 0.2
    vArray(6) = &H1000&
    vArray(7) = "VariantArray"
    vArray(5) = 16

    Call setArrayGEV(vArray)
    Call setArrayGED(dArray)
    Call setArrayGES(sArray)
    Call setArrayGEL(lArray)

    Call setArrayADV(vArray)
    Call setArrayADD(dArray)
    Call setArrayADS(sArray)
    Call setArrayADL(lArray)

End Sub

実行結果

getArrayPETest

 2             3             406 
 2             4             408 
 3             3             606 
 3             4             608 
 4             3             806 
 4             4             808 
 5             3             1006 
 5             4             1008 

GetArrayPE:1
GetArrayPE:2
GetArrayPE:3
GetArrayPE:4
GetArrayPE:5

getArrayADTest

 2             3            0x23
 2             4            0x24
 3             3            0x33
 3             4            0x34
 4             3            0x43
 4             4            0x44
 5             3            0x53
 5             4            0x54

 2             3            0x69
 2             4            0x6C
 3             3            0x99
 3             4            0x9C
 4             3            0xC9
 4             4            0xCC
 5             3            0xF9
 5             4            0xFC

GetArrayAD0
GetArrayAD1
GetArrayAD2
GetArrayAD3
GetArrayAD4

GetArrayAD_BSTR0
 4 
GetArrayAD_EMPTY2
GetArrayAD_EMPTY3

setArrayADTest

SetArrayGE

SetArrayAD

次回予告

次回は、Variant型の非配列変数に、配列を格納して、DLLと受け渡しをする予定です。

過去掲載分

z1000s.hatenablog.com
z1000s.hatenablog.com
z1000s.hatenablog.com
z1000s.hatenablog.com
z1000s.hatenablog.com
z1000s.hatenablog.com
z1000s.hatenablog.com