Tömb és WriteOnlyArray (C++/CX)

Használhat hagyományos C-stílusú tömböket vagy std::array C++/CX-programokat (bár std::vector ez gyakran jobb választás), de a metaadatokban közzétett API-kban a használat módjától függően C-stílusú tömböt vagy vektort Platform::Array kell átalakítania vagy Platform::WriteOnlyArray típussá alakítania. A Platform::Array típus nem olyan hatékony és nem is olyan hatékony, mint std::vector, ezért általános útmutatóként kerülnie kell a belső kódban való használatát, amely sok műveletet hajt végre a tömbelemeken.

A következő tömbtípusok továbbíthatók az ABI-n keresztül:

1. const Platform::Array^

2. Platform::Array^*

3. Platform::WriteOnlyArray

4. visszaadott értéke: Platform::Array^

Ezekkel a tömbtípusokkal implementálhatja a Windows futtatókörnyezet által definiált háromféle tömbmintát.

PassArray
Akkor használatos, ha a hívó átad egy tömböt egy metódusnak. A C++ bemeneti paraméter típusa constPlatform::Array<T.>

FillArray
Akkor használatos, ha a hívó átad egy tömböt a kitöltéshez. A C++ bemeneti paraméter típusa Platform::WriteOnlyArray<T>.

ReceiveArray
Akkor használatos, ha a hívó megkapja a metódus által lefoglalt tömböt. A C++/CX fájlban a tömböt a visszatérési értékben tömb^ értékként, vagy tömb^* típusú kimenő paraméterként is visszaadhatja.

PassArray-minta

Ha az ügyfélkód átad egy tömböt egy C++ metódusnak, és a metódus nem módosítja, a metódus elfogadja a tömböt const Array^. A Windows Futtatókörnyezeti alkalmazás bináris felülete (ABI) szintjén ezt PassArray-nak nevezzük. A következő példa bemutatja, hogyan adhat át egy JavaScriptben lefoglalt tömböt egy C++ függvénynek, amely olvas belőle.

//JavaScript
function button2_click() {
    var obj = new JS-Array.Class1();
    var a = new Array(100);
    for (i = 0; i < 100; i++) {
        a[i] = i;
    }
    // Notice that method names are camelCased in JavaScript.
    var sum = obj.passArrayForReading(a);
    document.getElementById('results').innerText
        = "The sum of all the numbers is " + sum;
}

Az alábbi kódrészlet a C++ metódust mutatja be:

double Class1::PassArrayForReading(const Array<double>^ arr)
{
    double sum = 0;
    for(unsigned int i = 0 ; i < arr->Length; i++)
    {
        sum += arr[i];
    }
    return sum;
}

ReceiveArray minta

A ReceiveArray-mintában az ügyfélkód deklarál egy tömböt, és átadja egy metódusnak, amely lefoglalja a memóriát, és inicializálja azt. A C++ bemeneti paraméter típusa egy mutató–kalap: Array<T>^*. Az alábbi példa bemutatja, hogyan deklarálhat egy tömbobjektumot a JavaScriptben, és hogyan adhatja át egy C++ függvénynek, amely lefoglalja a memóriát, inicializálja az elemeket, és visszaadja a JavaScriptnek. A JavaScript a lefoglalt tömböt visszatérési értékként kezeli, a C++ függvény azonban out paraméterként kezeli.

//JavaScript
function button3_click() {
    var obj = new JS-Array.Class1();

    // Remember to use camelCase for the function name.
    var array2 = obj.calleeAllocatedDemo2();
    for (j = 0; j < array2.length; j++) {
        document.getElementById('results').innerText += array2[j] + " ";
    }
}

Az alábbi kódrészlet a C++ metódus implementálásának két módját mutatja be:

// Return array as out parameter...
void Class1::CalleeAllocatedDemo(Array<int>^* arr)
{
    auto temp = ref new Array<int>(10);
    for(unsigned int i = 0; i < temp->Length; i++)
    {
        temp[i] = i;
    }

    *arr = temp;
}

// ...or return array as return value:
Array<int>^ Class1::CalleeAllocatedDemo2()
{
    auto temp = ref new Array<int>(10);    
    for(unsigned int i = 0; i < temp->Length; i++)
    {
        temp[i] = i;
    }

    return temp;
}

Tömbök kitöltése

Ha egy tömböt szeretne lefoglalni a hívóban, és inicializálni vagy módosítani szeretné a hívóban, használja a következőt WriteOnlyArray: . A következő példa bemutatja, hogyan implementálhat egy C++ függvényt, amely JavaScriptből használja WriteOnlyArray és hívja meg.

// JavaScript
function button4_click() {
    var obj = new JS-Array.Class1();
    //Allocate the array.
    var a = new Array(10);

    //Pass the array to C++.
    obj.callerAllocatedDemo(a);

    var results = document.getElementById('results');
    // Display the modified contents.
    for (i = 0; i < 10; i++) {
        document.getElementById('results').innerText += a[i] + " ";
    }
}

Az alábbi kódrészlet bemutatja, hogyan implementálhatja a C++ metódust:

void Class1::CallerAllocatedDemo(Platform::WriteOnlyArray<int>^ arr)
{
    // You can write to the elements directly.
    for(unsigned int i = 0; i < arr->Length; i++)
    {
        arr[i] = i;
    }   
}

Tömbkonvertálások

Ez a példa bemutatja, hogyan hozhat Platform::Array létre más típusú gyűjteményeket a következő módon:

#include <vector>
#include <collection.h>
using namespace Platform;
using namespace std;
using namespace Platform::Collections;

void ArrayConversions(const Array<int>^ arr)
{
    // Construct an Array from another Array.
    Platform::Array<int>^ newArr = ref new Platform::Array<int>(arr);

    // Construct a Vector from an Array
    auto v = ref new Platform::Collections::Vector<int>(arr); 

    // Construct a std::vector. Two options.
    vector<int> v1(begin(arr), end(arr));
    vector<int> v2(arr->begin(), arr->end());

    // Initialize a vector one element at a time.
    // using a range for loop. Not as efficient as using begin/end.
    vector<int> v3;
    for(int i : arr)
    {
        v3.push_back(i);
    }   
}

A következő példa bemutatja, hogyan hozhat létre egy Platform::Array C stílusú tömböt, és hogyan adja vissza egy nyilvános metódusból.

Array<int>^ GetNums()
{
    int nums[] = {0,1,2,3,4};
    //Use nums internally....

    // Convert to Platform::Array and return to caller.
    return ref new Array<int>(nums, 5);
}

Szaggatott tömbök

A Windows futtatókörnyezet típusú rendszer nem támogatja a szaggatott tömbök fogalmát, ezért nem használható IVector<Platform::Array<T>> visszatérési értékként vagy metódusparaméterként nyilvános metódusokban. Ha át szeretne adni egy szaggatott tömböt vagy sorozatsorozatot az ABI-n, használja a IVector<IVector<T>^>.

Az adatok másolásának elkerülése a ArrayReference használatával

Bizonyos esetekben, amikor az adatok az ABI-n keresztül kerülnek továbbításra, Platform::Arrayés végső soron egy C stílusú tömbben szeretné feldolgozni az adatokat a hatékonyság érdekében, a Platform::ArrayReference használatával elkerülheti a további másolási műveletet. Amikor egy argumentumot egy olyan paraméternek ad át Platform::ArrayReference , amely egy adott paramétert használ Platform::Array, az ArrayReference adatokat közvetlenül egy ön által megadott C-stílusú tömbbe fogja tárolni. Ne feledje, hogy ArrayReference a forrásadatok nincsenek zárolva, ezért ha a hívás befejeződése előtt módosítja vagy törli az adatokat egy másik szálon, az eredmények nem lesznek meghatározva.

Az alábbi kódrészlet bemutatja, hogyan másolhatja a művelet eredményeit DataReader egy Platform::Array (a szokásos mintába), majd hogyan helyettesítheti ArrayReference az adatokat közvetlenül egy C-stílusú tömbbe:

public ref class TestReferenceArray sealed
{
public:

    // Assume dr is already initialized with a stream
    void GetArray(Windows::Storage::Streams::DataReader^ dr, int numBytesRemaining)
    {
        // Copy into Platform::Array
        auto bytes = ref new Platform::Array<unsigned char>(numBytesRemaining);            

        // Fill an Array.
        dr->ReadBytes(bytes);

        // Fill a C-style array
        uint8 data[1024];
        dr->ReadBytes( Platform::ArrayReference<uint8>(data, 1024) );
    }
};

Tömbök tulajdonságként való felfedésének elkerülése

Általában kerülje a típusok tulajdonságként való felfedését Platform::Array egy ref osztályban, mert a rendszer akkor is visszaadja a teljes tömböt, ha az ügyfélkód csak egyetlen elemhez próbál hozzáférni. Ha egy sorozattárolót egy nyilvános hiv osztály tulajdonságaként kell elérhetővé tennie, Windows::Foundation::IVector jobb választás. Privát vagy belső API-kban (amelyeket nem tesznek közzé metaadatokon), érdemes lehet egy szabványos C++ tárolót használni, például std::vector.

Lásd még

Típus rendszer
C++/CX nyelvi referencia
Névterek – referencia