Question

这是一个类似于我定义的函数：

void Function( BYTE *data );

我想做的是这样的事情：

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

Answer 1

您不能将数组初始化语法与使用new的动态分配数组一起使用。你可以这样做：

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

但为什么你在这里使用动态分配的内存？数组是否保持在当前函数范围之外？如果没有，您可以使用堆栈上分配的数组：

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

在C ++中，首选方法是使用STL类std::vector，它类似于动态分配（但类型安全）的数组：

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

Answer 2

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

C ++ 0x将引入初始化列表语法，允许更接近您想要的内容。

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

如果您想要的只是将BYTE数组初始化为全零，则上述工作正常。（我假设这是Windows BYTE类型。）但是如上所述，这很容易泄漏，最好避免使用。

Answer 4

或者您可以使用省略号来模拟数组的构造：

看看这个：http://www.cplusplus.com/reference/clibrary/cstdarg/va_arg/

如果你真的想在0x到来之前摆弄，请看看this code。

Answer 5

gcc有一个名为“复合文字”的扩展名，允许你写：

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

请注意，它是在堆栈上分配的，因此可能不适合您的用途。

Answer 6

好吧，如果BYTE是一个类，你可以有一个构造函数

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

然后致电

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

但是，这很容易泄漏。您应该在退出Function之前删除该参数。而且这并不总是可行的（例如，如果你没有Function的来源）

Answer 7

辅助功能;

  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;

请记住，使用new[];

删除使用delete[]创建的数组

C ++ - 将数组传递给方法

7 个答案: