有没有办法在C+；中将匿名数组作为参数传递+；？ 我希望能够在C++中声明数组作为函数参数，如下面的示例代码（不编译）所示。有什么方法可以做到这一点（除了事先单独声明数组之外） #包括 静态void printary（int arrayLen，const int*array） { 对于（int i＝0；i

），如果使用旧的C++变体（前c++ 0x），则不允许。“匿名数组”您所引用的实际上是一个初始值设定项列表。现在C++11已退出，这可以通过内置的

初始值设定项列表

类型完成。理论上，如果编译器将其解析为C99或更高版本，您还可以使用

外部C

将其用作C样式的初始值设定项列表

例如：

int main()
{
    const int* p;
    p = (const int[]){1, 2, 3};
}

---

是和否。在当前版本的标准（ISO C++ 1998中，2003的内存），这是不可能的。但是，在下一版本的标准“C++ 0x”中（尽管它的名字暗示它将在200年发布，但最有可能在2010发布）。，使用std:：initializer_list是可能的。

不，而且这是一种糟糕的编码实践。只需声明

const int*foo={5,6,7,8,9}；

在函数调用之前。即使这样做有效，也不会加快程序或编译时间。值仍需要在内存中分配并通过函数调用传递。

这样可以编译，但我不建议这样做

#include <stdio.h>

struct arr
{
   int array[5];
};

static void PrintArray(int arrayLen, arr array)
{
   for (int i=0; i<arrayLen; i++) printf("%i -> %i\n", i, array.array[i]);
}

int main(int, char **)
{
   PrintArray(5, (arr){5,6,7,8,9});
   return 0;
}

#包括
结构arr
{
int数组[5]；
};
静态void打印数组（int数组、arr数组）
{
对于（int i=0；i您可以使用可变数量的参数，而不是传递数组：

static void PrintArray(int arrayLen, ...)
{
   int this_value;
   va_list array;

   va_start(array, arrayLen);
   for (int i=0; i<arrayLen; i++) 
   {
     this_value = va_arg(array, int);
     printf("%i -> %i\n", i, this_value);
   }
   va_end(array);
}

静态void打印数组（int arrayLen，…）
{
int这个值；
va_列表数组；
va_开始（阵列、阵列）；
对于（int i＝0；IDISCLAMIVER）：对于这个答案，我得到一些投票，但是它起源于2009，其中C++ C++即将被定义。对于现代C++，请在下面滚动。
好吧，试试使用boost

这里是使用Booo:：赋值库和更多的C++类编程的解决方案）
在C++11和C99中的
extern“C”
中允许使用类型转换：

void PrintArray(size_t len, const int *array)
{
    for(size_t i = 0; i < len; i++)
        printf("%d\n", array[i]);
}

int main(int argc, char **argv)
{
    PrintArray(5, (const int[]){1, 2, 3, 4, 5});
    return 0;
}

void打印数组（大小长度，常量整数*数组）
{
对于（大小i=0；i
另一种选择是在TR1库中使用数组，它很可能成为下一个标准的一部分，并且受到许多编译器的支持

#include <array>
#include <algorithm>
#include <iostream>

using std::tr1::array;
using std::cout;
using std::copy;
using std::ostream_iterator;

template <class Container>
void PrintArray(Container &values)
{
  copy(values.begin(), values.end(), ostream_iterator<int>(cout, "\n"));
}

int main()
{
  array<int, 5> values = {1, 2, 3, 4, 5};
  PrintArray(values);
}

#包括
#包括
#包括
使用std:：tr1:：array；
使用std：：cout；
使用std：：copy；
使用std：：ostream_迭代器；
模板
void打印数组（容器和值）
{
复制（values.begin（）、values.end（）、ostream_迭代器（cout，“\n”）；
}
int main（）
{
数组值={1,2,3,4,5}；
打印数组（值）；
}
对于C++0x，可以使用
std:：initializer\u list
（和foreach循环）

#包括
#包括
无效打印（常量标准：：初始值设定项\u列表和数组）
{
for（auto x:array）//C++0x foreach循环
std：：cout您可以在ANSI-C中使用良好的ol'

模板化C++与<代码> STD:：向量< /代码>，方便返回，另外
#include <stdarg.h>
#include <vector>
using namespace std ;

struct Point
{
  int x,y;
  Point():x(0),y(0){}
  Point( int ix, int iy ):x(ix),y(iy){}
  ~Point(){printf("%d %d - the point has been destroyed!\n",x,y);}
  void print(){printf("%d,%d\n",x,y);}
} ;

// Concrete example using a list of int
int* initFrom( int numItems, ... )
{
  int* list = new int[ numItems ] ;

  va_list listPointer;
  va_start( listPointer, numItems );

  for( int i = 0 ; i < numItems; i++ )
    list[ i ] = va_arg( listPointer, int ) ;

  return list ;
}

// templatized version.
template <typename T> vector<T> initFrom( int numItems, ... )
{
  vector<T> list ;
  list.resize( numItems ) ;

  va_list listPointer;
  va_start( listPointer, numItems );

  for( int i = 0 ; i < numItems; i++ )
    list[ i ] = va_arg( listPointer, T ) ;

  return list ;
}

int main()
{
  int* theList = initFrom( 4, 900, 2000, 1000, 100 ) ;
  for( int i = 0 ; i < 4 ; i++ )
    printf( "Item %d=%d\n", i, theList[i] );

  puts( "\n\n--Lots of destruction using non-ptr" ) ;
  vector<Point> thePoints = initFrom<Point>( 3, Point(3,7), Point(4,5), Point(99,99) ) ;
  puts( "Our listing:" ) ;
  for( int i = 0 ; i < 3 ; i++ )
    thePoints[i].print() ;

  puts( "\n\n-- Less destruction using ptr" ) ;
  // Be careful of extra copy construction. Using a vector of pointers
  // will avoid that
  vector<Point*> theNewPoints = initFrom<Point*>( 3, new Point(300,700), new Point(400,500), new Point(990,990) ) ;
  puts( "Our listing:" ) ;
  for( int i = 0 ; i < 3 ; i++ )
    theNewPoints[i]->print() ;

  puts( "END OF PROGRAM --" ) ;
}

#包括
#包括
使用名称空间std；
结构点
{
int x，y；
点（）：x（0），y（0）{}
点（intix，intiy）：x（ix），y（iy）{
~Point（）{printf（“%d%d-该点已被销毁！\n”，x，y）；}
void print（）{printf（“%d，%d\n”，x，y）；}
} ;
//使用int列表的具体示例
int*initFrom（int numItems，…）
{
int*list=newint[numItems]；
列表指针；
va_开始（列表指针，numItems）；
对于（int i=0；iprint（）；
puts（“程序结束--”）；
}
您可以使用Joe D建议的std:：initializer\u list list，但是如果您需要其他参数，我不确定您是否可以使用它。（我似乎找不到任何相关信息。）但是，如果您声明对向量的常量引用，则使用{…}创建的initializer\u list将转换为向量

#include <iostream>
#include <vector>

void PrintArray(const char* prefix, const std::vector<int>& array)
{
    std::cout << prefix << std::endl;
    for (int i : array) {
        std::cout << i << std::endl;
    }
}

int main(int, char **)
{
    PrintArray("test array", {5,6,7,8,9} );
    return 0;
}

#包括
#包括
void printary（常量字符*前缀，常量标准：：向量和数组）
{
std:：cout从C++11开始，您只需使用
std:：begin（std:：initializer\u list const&）
来获取指针。示例：

#include <iostream>
void func(int len, const int* x)
{
    for(int i=0;i<len;++i)
        std::cout << x[i] << "\n";
}
int main()
{
    func(5, std::begin({1,3,6,823,-35}));
}

#包括
无效函数（整数长度，常数整数*x）
{
对于（int i=0；i，这里有一个简单的干净解决方案，可以获得其他人都没有提到的C样式数组：

#include <iostream>

using namespace std;

template <int N>
int
get_last( const int ( &my_array )[N] ) {
  return my_array[N-1];
}


int main()
{
    cout << "Last: " << get_last( { 1, 2, 3, 55 } );

    return 0;
}

#包括
使用名称空间std；
模板
int
获取最后一个（常量int（&my\u数组）[N]）{
返回我的_数组[N-1]；
}
int main（）
{
难道使用初始化器列表并不是“糟糕的编码实践”吗，只要您在适当的地方使用它们。目的不是加快编译时或运行时，而是改进封装。特别是，我有一个基类，它的构造函数接受字符串数组，子类的构造函数知道数组应该是什么。但无法
#include <stdarg.h>
#include <vector>
using namespace std ;

struct Point
{
  int x,y;
  Point():x(0),y(0){}
  Point( int ix, int iy ):x(ix),y(iy){}
  ~Point(){printf("%d %d - the point has been destroyed!\n",x,y);}
  void print(){printf("%d,%d\n",x,y);}
} ;

// Concrete example using a list of int
int* initFrom( int numItems, ... )
{
  int* list = new int[ numItems ] ;

  va_list listPointer;
  va_start( listPointer, numItems );

  for( int i = 0 ; i < numItems; i++ )
    list[ i ] = va_arg( listPointer, int ) ;

  return list ;
}

// templatized version.
template <typename T> vector<T> initFrom( int numItems, ... )
{
  vector<T> list ;
  list.resize( numItems ) ;

  va_list listPointer;
  va_start( listPointer, numItems );

  for( int i = 0 ; i < numItems; i++ )
    list[ i ] = va_arg( listPointer, T ) ;

  return list ;
}

int main()
{
  int* theList = initFrom( 4, 900, 2000, 1000, 100 ) ;
  for( int i = 0 ; i < 4 ; i++ )
    printf( "Item %d=%d\n", i, theList[i] );

  puts( "\n\n--Lots of destruction using non-ptr" ) ;
  vector<Point> thePoints = initFrom<Point>( 3, Point(3,7), Point(4,5), Point(99,99) ) ;
  puts( "Our listing:" ) ;
  for( int i = 0 ; i < 3 ; i++ )
    thePoints[i].print() ;

  puts( "\n\n-- Less destruction using ptr" ) ;
  // Be careful of extra copy construction. Using a vector of pointers
  // will avoid that
  vector<Point*> theNewPoints = initFrom<Point*>( 3, new Point(300,700), new Point(400,500), new Point(990,990) ) ;
  puts( "Our listing:" ) ;
  for( int i = 0 ; i < 3 ; i++ )
    theNewPoints[i]->print() ;

  puts( "END OF PROGRAM --" ) ;
}

#include <iostream>
#include <vector>

void PrintArray(const char* prefix, const std::vector<int>& array)
{
    std::cout << prefix << std::endl;
    for (int i : array) {
        std::cout << i << std::endl;
    }
}

int main(int, char **)
{
    PrintArray("test array", {5,6,7,8,9} );
    return 0;
}

#include <iostream>
void func(int len, const int* x)
{
    for(int i=0;i<len;++i)
        std::cout << x[i] << "\n";
}
int main()
{
    func(5, std::begin({1,3,6,823,-35}));
}

#include <iostream>

using namespace std;

template <int N>
int
get_last( const int ( &my_array )[N] ) {
  return my_array[N-1];
}


int main()
{
    cout << "Last: " << get_last( { 1, 2, 3, 55 } );

    return 0;
}