C ++ - Passando Arrays métodos para

Question

Aqui está uma função semelhante à que eu defini:

void Function( BYTE *data );

O que eu gostaria de fazer é algo como isto:

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

Answer 1

Você não pode usar a sintaxe initialiser matriz com matrizes alocadas dinamicamente usando new. Você poderia fazer algo parecido com isto:

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

Mas por que você está usando a memória alocada dinamicamente aqui? É a matriz segurei fora do escopo da função atual? Se não, você pode usar uma matriz alocada na pilha:

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

C ++, um método preferido é a utilização do std::vector classe STL que actua como um alocada dinamicamente (mas segura tipo) de matriz:

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

Answer 2

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

C ++ 0x irá introduzir initializer sintaxe lista que vai permitir algo mais próximo do que você queria acima.

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;
}

As obras acima se tudo que você sempre quis foi inicializar a matriz BYTE para todos os zeros. (Estou assumindo que este é o tipo BYTE do Windows.) No entanto, este é fuga propensas como mencionado e é melhor evitar.

Answer 4

Ou você poderia usar o reticências para construção imitador de sua matriz:

dar uma olhada nisso: http://www.cplusplus.com/ referência / clibrary / cstdarg / va_arg /

E se você realmente quer mexer antes do 0x chega, dê uma olhada este código .

Answer 5

gcc tem uma extensão chamada "literais compostos", que permite que você escreva:

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

Note que é alocado na pilha, por isso pode não ser adequado para seus propósitos.

Answer 6

Bem, se BYTE é uma classe, você poderia ter um construtor

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

e, em seguida, chamar

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

No entanto, este é leak-propenso. Você deve excluir o argumento antes Função sair. E isso nem sempre é possível (por exemplo, se você não tem fonte de Função)

Answer 7

Função auxiliar;

  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;

Basta lembrar, matrizes criadas com new[] são apagados com delete[];