Параметр - что-то, что необходимо заполнить, когда Вы вызываете функцию. То, что Вы вставляете его, является аргументом.
Просто набор: аргумент входит в параметр, аргументом является значение параметра.
[еще 113] информация о: http://en.wikipedia.org/wiki/Parameter_ (computer_science) #Parameters_and_arguments
Если вы используете более старые варианты C ++ (до C ++ 0x), то это запрещено. «Анонимный массив», на который вы ссылаетесь, на самом деле является списком инициализаторов . Теперь, когда C ++ 11 вышел, это можно сделать с помощью встроенного типа initializer_list
. Теоретически вы также можете использовать его как список инициализаторов в стиле C, используя extern C
, , если ваш компилятор анализирует их как C99 или новее .
Например:
int main()
{
const int* p;
p = (const int[]){1, 2, 3};
}
Это компилируется, но я бы не рекомендовал его.
#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;
}
Это разрешено с приведением типов в C ++ 11 и в extern "C"
с C99:
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;
}
Что ж, попробуйте использовать boost ...
Вот решение, использующее библиотеку boost :: assign и немного больше программирования на C ++;)
#include <boost/assign/list_of.hpp>
#include <iostream>
#include <algorithm>
namespace
{
template<class CollectionT>
void print(CollectionT const& coll)
{
std::ostream_iterator<int> out(std::cout, ", ");
std::copy(coll.begin(), coll.end(), out);
}
}
int main()
{
using namespace boost::assign;
print( list_of(1)(2)(3)(4)(5) );
return 0;
}
Выполняется с лязгом:
clang ++ -std = c ++ 14 -I / usr / local / include / main.cpp
#include <boost/assign/list_of.hpp>
#include <iostream>
#include <iterator>
#include <algorithm>
#include <initializer_list>
template<typename CollectionT, typename OStream>
auto // <- auto result type deduction from C++ 14
make_output_iterator(CollectionT const& coll, OStream& out)
{
return std::ostream_iterator<typename CollectionT::value_type>(out, ", ");
}
// here template specialization is used, to demonstrate initializer lists from C++ 11
template<typename T>
void print(std::initializer_list<T> items)
// ^----------------------^ passed by value due to move semantics
{
using namespace std;
cout << "printing an initializer list: ";
copy(items.begin(), items.end(), make_output_iterator(items, cout));
cout << endl;
}
template<typename CollectionT>
void print(CollectionT const& items)
{
using namespace std;
cout << "printing another collection type: ";
copy(items.begin(), items.end(), make_output_iterator(items, cout));
cout << endl;
}
int main()
{
print({0,1,2,3,4,5,6,7,9});
using namespace boost::assign;
print( list_of(0)(1)(2)(3)(4)(5)(6)(7)(8)(9) );
}
Да и нет. В текущей версии стандарта (ISO C ++ 1998 с поправками 2003 г.) это невозможно. Однако в следующей версии стандарта «C ++ 0x» (который, несмотря на его название, подразумевающее, что он будет выпущен в 200x, скорее всего, будет выпущен в 2010 году), это будет возможно с помощью std :: initializer_list <> .
Вы можете использовать переменное количество аргументов вместо передачи массива:
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);
}
Я не компилировал это, поэтому я, вероятно, сделал пару ошибок, но, надеюсь, это достаточно близко. Найдите ссылку на va_start.
Другой вариант - использовать массив в библиотеке 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);
}
Нет, и в любом случае это плохая практика кодирования. Просто объявите const int * foo = {5,6,7,8,9};
перед вызовом функции. Даже если бы это сработало, это не ускорило бы вашу программу или время компиляции. Значения все равно нужно будет выделить в памяти и передать через вызов функции.
В C ++ 0x вы можете использовать std :: initializer_list
(и цикл foreach)
#include <iostream>
#include <initializer_list>
void print (const std::initializer_list<int>& array)
{
for (auto x : array) // C++0x foreach loop
std::cout << x << std::endl;
}
int main (int argc, char ** argv)
{
print ({ 1, 2, 3, 4, 5 });
}