функции с переменным числом аргументов, но без фиксированных - C/C++

язык с++ позволяет объявить функцию вот так:

void SomeFun(...)
{
// сделать что нибудь
}

и вызывать ее

..............
SomeFun();
SomeFun(1) ;
SomeFun(1,2,3) ;
SomeFun("111", 3.141592) ;

но как в теле функции узнать параметры???
стандартные средства va_start итд требуют наличия фиксированных параметров, а нужна возможность вызова без параметров.

Здравствуйте, Chegermek, Вы писали:

C>язык с++ позволяет объявить функцию вот так:

C>

C>void SomeFun(...)
C>{
C>// сделать что нибудь
C>}
C>

C>и вызывать ее

C>

C>..............
C>SomeFun();
C>SomeFun(1) ;
C>SomeFun(1,2,3) ;
C>SomeFun("111", 3.141592) ;
C>

C>но как в теле функции узнать параметры???
C>стандартные средства va_start итд требуют наличия фиксированных параметров, а нужна возможность вызова без параметров.

void SomeFun() {}

template < typename T1 >
void SomeFun( T1 p1 ) {}

template < typename T1, typename T2 >
void SomeFun( T1 p1, T2 p2 ) {}

template < typename T1, typename T2, typename T3 >
void SomeFun( T1 p1, T2 p2, T3 p3 ) {}

ы?

Здравствуйте, _Dreamer, Вы писали:

_D>

_D>void SomeFun() {}

_D>template < typename T1 >
_D>void SomeFun( T1 p1 ) {}

_D>template < typename T1, typename T2 >
_D>void SomeFun( T1 p1, T2 p2 ) {}

_D>template < typename T1, typename T2, typename T3 >
_D>void SomeFun( T1 p1, T2 p2, T3 p3 ) {}
_D>

_D>ы?

в конкретной задаче предполагается до 256 аргументов!!!

Здравствуйте, Chegermek, Вы писали:

C>в конкретной задаче предполагается до 256 аргументов!!!

Пахнет bad design

а как ты отличишь
foo(1);
от
foo("1");
?

Здравствуйте, Chegermek, Вы писали:

C>в конкретной задаче предполагается до 256 аргументов!!!

Вам такие задачи инопланетяне чтоли ставят ?
упаковывайте параметры в структуру и передавайте структурой. или массивом. но через стек то зачем ?

Здравствуйте, Аноним, Вы писали:

А>а как ты отличишь
А>foo(1);
А>от
А>foo("1");
А>?

это уже другой вопрос, а вообщето типы аргументов одинаковые и известные

Здравствуйте, _Dreamer, Вы писали:

_D>Вам такие задачи инопланетяне чтоли ставят ?
_D>упаковывайте параметры в структуру и передавайте структурой. или массивом. но через стек то зачем ?

256 аргументов это крайний случай, которого скорее всего никогда не будет, но возможность предусмотрена должна быть, а если создать структуру 256 элементов, то ВСЕГДА прийдется передавать по килобайту памяти.

Здравствуйте, Chegermek, Вы писали:

C>Здравствуйте, _Dreamer, Вы писали:

_D>>Вам такие задачи инопланетяне чтоли ставят ?
_D>>упаковывайте параметры в структуру и передавайте структурой. или массивом. но через стек то зачем ?

C>256 аргументов это крайний случай, которого скорее всего никогда не будет, но возможность предусмотрена должна быть, а если создать структуру 256 элементов, то ВСЕГДА прийдется передавать по килобайту памяти.

а как насчет ссылок или указателей?

Здравствуйте, Chegermek, Вы писали:

C>Здравствуйте, _Dreamer, Вы писали:

_D>>Вам такие задачи инопланетяне чтоли ставят ?
_D>>упаковывайте параметры в структуру и передавайте структурой. или массивом. но через стек то зачем ?

C>256 аргументов это крайний случай, которого скорее всего никогда не будет, но возможность предусмотрена должна быть, а если создать структуру 256 элементов, то ВСЕГДА прийдется передавать по килобайту памяти.

по мойму, кто то кого то недопонимает


struct some_params
{
  std::vector< int > values;
};

void some_fun( const some_params * params = NULL ) // всегда sizeof(const some_params *) байта, а не килобайт вовсе
{
  // ...
  if ( params == NULL )
  {
    // без параметров
  }
}

int main()
{
  some_params params;
  // ... заполняем

  some_fun( &params );
  some_fun();
}

_Dreamerу и Анониму

если не передавать, то хранить килобайтную структуру в которой заполнены 3 поля тоже не охота, а вообще интересно не совсем это, а то, что если язык позволяет это делать, то должен быть способ.

Здравствуйте, Chegermek, Вы писали:

C>если не передавать, то хранить килобайтную структуру в которой заполнены 3 поля тоже не охота, а вообще интересно не совсем это, а то, что если язык позволяет это делать, то должен быть способ.

1. std::vector с 3 элементами занимает отнюдь не килобайт.
2. Даже если и занимал бы: у вас что, пары лишних килобайт нет?
3. FYI, C++ позволяет, а C99 не позволяет. Так что, возможно, такие функции из языка вообще уберут.

Кроме того, самый кошерный способ передачи последовательности такой:

template <class InputIterator>
void doSomething(InputIterator first, InputIterator last);

Пример использования:

// 1

std::deque<SomeType> values;

while(. . .)
{
    values.push_back(. . .);
}

doSomething(values.begin(), values.end());

// 2

SomeType values[4];
values[0] = getSomeValue();
values[1] = getSomeValue();
values[2] = getSomeValue();
values[3] = getSomeValue();

doSomething(values, values + 4);
// или:
doSomething(boost::begin(values), boost::end(values));

Здравствуйте, Roman Odaisky, Вы писали:

RO>1. std::vector с 3 элементами занимает отнюдь не килобайт.
я имел в виду свой случай с 256 параметрами
RO>2. Даже если и занимал бы: у вас что, пары лишних килобайт нет?
зависит от платформы
RO>3. FYI, C++ позволяет, а C99 не позволяет. Так что, возможно, такие функции из языка вообще уберут.
убрать не должны из за совместимости

RO>Кроме того, самый кошерный способ передачи последовательности такой:
RO>

RO>template <class InputIterator>
RO>void doSomething(InputIterator first, InputIterator last);
RO>

способ действительно прикольный

но всетаки интересно ктонить знает как реализовать изначальный вопрос???

> но всетаки интересно ктонить знает как реализовать изначальный вопрос???

Без грязных хаков — никак. Я серьезно.

Posted via RSDN NNTP Server 2.0

Здравствуйте, Аноним, Вы писали:

А>но всетаки интересно ктонить знает как реализовать изначальный вопрос???

Либо передать их кол-во

void some_func(size_t count, ...)
{
}

Либо знать признак конца

void some_func(int i, ...)
{
  va_list argptr;
  va_start(argptr, i);
  while (true)
  {
    char * str= va_arg(argptr, char *);
    if (str == NULL) break;
    std::cout << str << std::endl;
  }
}

int main()
{
  some_func(0, "hello", "world", NULL);
}

Здравствуйте, Chegermek, Вы писали:

C>в конкретной задаче предполагается до 256 аргументов!!!

и чё с помощью BOOST_PP_ не нагенеришь 256 шаблонов чтоли?

Здравствуйте, Аноним, Вы писали:

А>но всетаки интересно ктонить знает как реализовать изначальный вопрос???

Если передаваемые типы известны, и их фиксированное количество, может, стоит сделать аналог Variant'а? И передавать вектор вариантов.

Здравствуйте, Chegermek, Вы писали:

C>язык с++ позволяет объявить функцию вот так:

C>

C>void SomeFun(...)
C>{
C>// сделать что нибудь
C>}
C>

C>и вызывать ее

C>

C>..............
C>SomeFun();
C>SomeFun(1) ;
C>SomeFun(1,2,3) ;
C>SomeFun("111", 3.141592) ;
C>

C>но как в теле функции узнать параметры???
C>стандартные средства va_start итд требуют наличия фиксированных параметров, а нужна возможность вызова без параметров

Если тебе извесны какие типы, и ты говорил что ты знаеш даже какой, то не проще ли сделать так.

например возмем для примера тип T.

void SomeFun( const T &t, ... );

Здравствуйте, Chegermek, Вы писали:

C>язык с++ позволяет объявить функцию вот так:

C>

C>void SomeFun(...)
C>{
C>// сделать что нибудь
C>}
C>

C>и вызывать ее

C>

C>..............
C>SomeFun();
C>SomeFun(1) ;
C>SomeFun(1,2,3) ;
C>SomeFun("111", 3.141592) ;
C>

C>но как в теле функции узнать параметры???
C>стандартные средства va_start итд требуют наличия фиксированных параметров, а нужна возможность вызова без параметров.

стандартными средствами такое сделать нельзя, но почему бы не создать один фиктивный первый аргумент,
если уж так хочется прострелить себе ногу.

Задача говорит сама за себя — АРХИТЕКТУРНАЯ ОШИБКА.
Скорее всего в голове

... << RSDN@Home 1.1.4 stable SR1 rev. 568>>

Здравствуйте, Chegermek, Вы писали:

C>

C>..............
C>SomeFun();
C>SomeFun(1) ;
C>SomeFun(1,2,3) ;
C>SomeFun("111", 3.141592) ;
C>

Сначала один вопрос. А можно лизвать SomeFun вообще без параметров?

Ну а теперь идеи:

Идея 1

void SomeFun();
template<typename T> void SumeFun( T t, ... )
{
    // тут сам догадаешься
}

При этом хочу заметить, что результат передачи экземпляра класса через ... зависит от реализации!

Вообще, насколько я понимаю C++-way надо смотреть в сторону cout:
Идея 2

class Args {
    //  тут тоже сам догадаешься
};

void SomeFun( Args );

void foo()
{
    SomeFun( Args() << arg1 << arg2 << arg3 ); 
}

Но лично мне больше нравится так:

Идея 2.5

class SomeFunImpl {
public:
    template<typename T>
    SomeFunImpl& operator << ( const T& );

    void Process()
};

void foo()
{
    SomeFunImpl processor;
    processor << arg1 << arg2 << arg3 << arg4 << ...;
    processor.Process();
}

Все эмоциональные формулировки не соотвествуют действительному положению вещей и приведены мной исключительно "ради красного словца". За корректными формулировками и неискажённым изложением идей, следует обращаться к их автором или воспользоваться поиском

	От:	Chegermek
	Дата:	16.02.07 09:34
	Оценка:

	От:	_Dreamer
	Дата:	16.02.07 09:57
	Оценка:

	От:	Chegermek
	Дата:	16.02.07 10:08
	Оценка:

	От:	Аноним
	Дата:	16.02.07 10:22
	Оценка:

	От:	_Dreamer
	Дата:	16.02.07 10:33
	Оценка:

	От:	Roman Odaisky
	Дата:	16.02.07 12:24
	Оценка:	1 (1)

	От:	frogkiller
	Дата:	17.02.07 14:25
	Оценка:

	От:	IROV..
	Дата:	17.02.07 19:51
	Оценка:	+1

	От:	dkotov
	Дата:	17.02.07 23:29
	Оценка:

	От:	Erop
	Дата:	18.02.07 00:00
	Оценка: