C ++ - Passare array ai metodi

Question

Ecco una funzione simile a quella che ho definito:

void Function( BYTE *data );

Quello che vorrei fare è qualcosa del genere:

Function( new BYTE { 0x00, 0x00 } );

Answer 1

Non è possibile utilizzare la sintassi dell'inizializzatore di array con array allocati dinamicamente utilizzando new . Potresti fare qualcosa del genere:

BYTE *ary=new BYTE[2];
ary[0] = 0;
ary[1] = 0;
Function(ary);
delete [] ary;

Ma perché stai usando la memoria allocata dinamicamente qui? L'array è tenuto al di fuori dell'ambito della funzione corrente? In caso contrario, è possibile utilizzare un array allocato nello stack:

BYTE ary[2] = {0};
Function(ary);

In C ++, un metodo preferito è usare la classe STL std :: vector che agisce come un array allocato dinamicamente (ma di tipo sicuro):

std::vector<BYTE> ary(2);
Function(&ary[0]);

Answer 2

BYTE foo[] = { 0x00, 0x00 };
Function( foo );

C ++ 0x introdurrà la sintassi dell'elenco di inizializzatori che consentirà qualcosa di più vicino a quello che volevi sopra.

Answer 3

#include <windows.h>
#include <iostream>
using namespace std;
void foo(BYTE *d) {
    cout << (int)d[ 0 ] << " " << (int)d[ 1 ] << endl;
}
int main(void) 
{
    foo(new BYTE[ 2 ]());
    return 0;
}

Quanto sopra funziona se tutto ciò che avessi sempre desiderato era inizializzare l'array BYTE a tutti gli zeri. (Suppongo che questo sia il tipo BYTE di Windows.) Tuttavia, questo è soggetto a perdite come menzionato ed è meglio evitarlo.

Answer 4

Oppure potresti usare i puntini di sospensione per imitare la costruzione del tuo array:

dai un'occhiata a questo: http://www.cplusplus.com/ riferimento / clibrary / cstdarg / va_arg /

E se vuoi davvero giocherellare prima dell'arrivo dello 0x, dai un'occhiata a questo codice .

Answer 5

gcc ha un'estensione chiamata " Compositi letterali " ;, che ti permette di scrivere:

Function((BYTE[]){1, 2, 3, 4});

Nota che è allocato in pila, quindi potrebbe non essere adatto ai tuoi scopi.

Answer 6

Bene, se BYTE è una classe, potresti avere un costruttore

BYTE::BYTE(char c1,char c2){
 //something here.
}

e quindi chiama

Function( new BYTE(0X00,0X00))

Tuttavia, questo è soggetto a perdite. È necessario eliminare l'argomento prima di uscire da Function. E questo non è sempre possibile (ad esempio se non si dispone della fonte Function)

Answer 7

Funzione ausiliaria;

  BYTE* makeNaryByteArray( int n, BYTE exemplar = 0 ) {
    BYTE* r = new BYTE[ n ];
    for( int i = 0 ; i < n ; ++i )
       n[i] = exemplar;
    return r;
  }

  //call them:
  BYTE* myByteArray;
  Function( myByteArray = makeNaryByteArray(2) );

  // done with array:
  delete[] myByteArray;

Ricorda, le matrici create con new [] vengono eliminate con delete [] ;