Передача в функцию переменного кол-ва аргументов РАЗНЫХ типов

[Пепел Феникса]

Krok27, откуда ноль должен взяться?

[Krok27]

В параметрах.

int sum ( int first , . . . )
{
va_list vl ;
int result = first ;
va_start (vl , first ) ;
while (first ! = 0 )
{
first = va_arg (vl , int ) ;
result += f irst ;
}
va_end (vl ) ;
return result ;
}
. . .
int x = sum ( 1 , 2 , 3 , 4 , 5 , 0 )

Как то так.

[Пепел Феникса]

это пойдет только при однотипных параметрах и только при ограничении что 0 не может быть, то есть не случай ТС.

[Krok27]

Ога. Но имеет быть место.

[stranger84]

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

PHP код:

/*
(c) Анос Андрей
aka stranger84
*/

#include <stdarg.h>
#include <iostream>


void main()
{
    char buff[100];
    double b = 5321.545;

    aprintf(buff, "+%d", "\n+%0f+", '\0', 654, b);

    for(int i=0; buff[i]!='\0';i++)
        std::cout << buff[i];
    std::cout << std::endl;
}


/*
Значения параметров:
d, i    — десятичное знаковое число, размер по умолчанию, sizeof( int ). 
u        — десятичное беззнаковое число, размер по умолчанию sizeof( int );
f и F    — числа с плавающей запятой. Аргумент по умолчанию имеет размер double.
        Если полсе символа % и перед F стоит число, то такое кол-во цифр будет 
        отображатся ПОСЛЕ запятой. по умолчанию значение установлено на 2
        значащихся символа
        printf("%4f\n", 12345.1234567);    Вывод : 12345.1235
c        — вывод символа с кодом, соответствующим переданному аргументу; 
        переданное число приводится к типу unsigned char
s        — вывод строки с нулевым завершающим байтом

char aprintf(char *return_str,        ...        ,        ...)
                    ^                ^        ^        ^
                буфер        list of params    '\0'    list of vars
*/

char aprintf(char *return_str, ...)
{
    char buf[50];
    char *pbuf = &buf[0];

    va_list pvalist;        
    va_start(pvalist, return_str);

    // получаю list of parameters и запись во временный буфер 
    char *formatList = va_arg(pvalist, char*);
    while (formatList != NULL){
        pbuf = strcopy(pbuf, formatList);
        formatList = va_arg(pvalist, char*);
    }
    pbuf = &buf[0];

    // здесь разбор строки из list of parameters
    // на предмет нахождения управляющего символа (%)
    for(; *pbuf != '\0'; pbuf++)
    {
        // если обычный символ, то просто копировать в 
        // результирующую строку и продолжать цикл 
        if(*pbuf != '%')
        {
            *return_str = *pbuf;
            return_str++;
            continue;
        }


        // --------------------------------------------------
        // а вот сюда мы попадаем если текущий символ = '%'. 
        // Производится парсинг в зависимости от введённых параметров 

        pbuf++;
        
        // d, i — десятичное знаковое число
        if( (*pbuf == 'd') || (*pbuf == 'D') ||
            (*pbuf == 'i') || (*pbuf == 'I') )
        {
            intToStr(va_arg(pvalist, int), return_str);
            return_str = eatZeros(return_str);
            continue;
        }

        // Параметр %f выводит число с плаваящей запятой 
        if( (*pbuf == 'f') || (*pbuf == 'F') || 
            (*pbuf >= '0') && (*pbuf <= '9') )
        {
            // кол-во цифр будет отображатся ПОСЛЕ запятой. 
            // по умолчанию значение установлено на 2 символа
            int numbers_after_point = 2;
            if( (*pbuf >= '0') && (*pbuf <= '9') )
            {
                numbers_after_point = *pbuf - '0';
                pbuf++;
            }

            // получаем число из стека
            double drobn = va_arg(pvalist, double);
            // округляем его до нужного нам знака
            drobn = round(drobn, numbers_after_point);
            // получаю целую часть
            int celoe = (int)drobn;         
            // получаю дробную часть 
            drobn = drobn - celoe;    
            intToStr(celoe, return_str);
            return_str = eatZeros(return_str);
            *return_str = '.'; 
            *(++return_str) = '\0';
            if (drobn < 0)
                drobn = -drobn;
             
            //постоянно умножая на число 10 я вытаскиваю из дробной части 
            //по одной цифре и тут же засовываю в результир строку.
            //функция IntToStr не использовалась т.к. невозможно избежать 
            //удаления значащих предварительных нулей перед числом в дробной части. 
            for(int i = 0; i <= numbers_after_point; i++)
            {
                drobn = drobn * 10;
                *return_str = (int)drobn + '0';
                *(++return_str) = '\0';
                drobn = drobn - (int)drobn;
            }
            continue;
        }

        // Параметр %c выводит символ 
        if( (*pbuf == 'c') || (*pbuf == 'C')  )
        {
            // записываю символ в результирующую строку 
            *return_str = va_arg(pvalist, unsigned char);
            return_str++;
            continue;
        }

        // Параметр %s выводит строку 
        if( (*pbuf == 's') || (*pbuf == 'S')  )
        {
            char *pTempStr = va_arg(pvalist, char*);
            for(; *pTempStr != '\0'; pTempStr++, return_str++)
                *return_str = *pTempStr;
            continue;
        }
    }
    // парсинг завершён. "завершение" строки
    *return_str = '\0';
    // закрытие указателя на структуру va_list
    va_end(pvalist);
    // если успешное завершение, то - 0
    return 0;
} 


[stranger84]

PHP код:

/*
(c) Анос Андрей
aka stranger84
*/

double round(double rounded_value, char numbers_after_point)
{
    // переменная которая будет хранить 10^numbers_after_point
    int tenInStepen = 1;

    // возведение 10^numbers_after_point
    for(int i = 0; i < numbers_after_point; i++)
        tenInStepen = tenInStepen * 10;
    rounded_value = rounded_value * tenInStepen;
    // число по которому буду судить в какую сторону округлять
    // почему-то если написать 
    // char numb = (int) (rounded_value - (int)rounded_value) * 10; 
    // работать не будет о_О
    char numb = (rounded_value - (int)rounded_value) * 10; 
    rounded_value = (int)rounded_value;
    if( (numb >= 5) && (numb <= 9) )
        rounded_value++;
    rounded_value = rounded_value / tenInStepen;
    return rounded_value;
}


//Функция копирующая строку src в строку dst
//Возвращает указатель на последний ('\0') символ dst
inline char *strcopy (char *dst, const char *src)
{
    for( ; *src != '\0'; src++, dst++)
        *dst = *src;
    *dst = '\0';
    return dst;
}


// Процедура удаляющая из строки предваряющие нули после функции intToStr
// Пример: 
// str[] = "00000054321"; результир строка :
// str[] = "54321"
// Возвращаемое значение - указатель на конец (\0) отформатированной строки
char *eatZeros(char *str)
{
    char *tmp = str;
    // если первый символ минус, то "перепрыгиваю" его
    if (*tmp == '-'){
        tmp++; str++;
    }
    
    for(; *tmp == '0'; tmp++);
    for(; *tmp != '\0'; tmp++, str++)
        *str = *tmp;
    *str = '\0';
    return str;
}

/* процедура перевода переменной типа integer в массив char-ов 
Пример:
int iVar = 874905855;
char str[] = {'8','7','4','9','0','5','8','5','5'};
Для этого делим i сначала на самое большое число для выделения сотен тысяч, 
потом десятков тысяч, потом просто тясяч и прибавляем к ним ASCII код "0"

Возвращает указатель на последний элемент в строке (\0). Это будет нужно при 
преобразованиях float-ов чтобы дописывать в конец
*/
char *intToStr(int iVar, char *str)
{
    // если разлагаемое число = 0, то нет смысла впустую гонять цикл когда 
    // можно сразу дать результат
    if(iVar == 0)
    {
        *str = '0'; *(++str) = '\0';
        return str;
    }

    // если число отрицательное, то результирующая строка 
    // дополняется символом "минус" перед массивом чисел 
    if (iVar < 0) {
        *str = '-'; str++; iVar = -iVar;
    }

    // переменные обозначающие числитель (NUMerator) 
    // и знаменатель (DENUMerator)
    int num = iVar, denum;        
    for(int i = 1000000000; i > 0; i = i/10, str++)
    {
        denum = num % i;
        num = num / i;
        *str = num + '0';
        num = denum;
    }
    *str = '\0';
} 


Основными бажными местами является :
1) результат функции double round(double, char), а в частности строка "rounded_value = rounded_value / tenInStepen;"
2) кусок кода

			for(uint8_t i = 0; i <= numbers_after_point; i++)
			{
				drobn = drobn * 10;
				*return_str = (int8_t)drobn + '0';
				*(++return_str) = '\0';
				drobn = drobn - (int32_t)drobn;
			}

в этих местах из-за погрешности в операциях с плав точкой вылазиют ну такие результаты что на голову не нализиет
например:

rounded_value = 2343; tenInStepen = 10;
rounded_value = rounded_value / tenInStepen;
rounded_value   <---- после деления == 234.29..

если подскажите как побороть эту напасть буду благодарен



также в планах модифицировать макрос va_arg чтобы он мог ещё и возвращать предыдущей указатель на что-то там из стека.
таким образом я могу избавится от временного буфера (а это экономия в 50 байт) + могу напрямую манипулировать данными через стек.

Думал сделать так:

//стандартная реализация в stdarg.h
va_arg(ap, type)	
	#define va_arg(ap, type) (*(type _FAR *)(((*(char _FAR *_FAR *)&
		(ap))+=((sizeof(type)+1) & 0xFFFE))-(((sizeof(type)+1) & 0xFFFE))))


// моя вариация
// если что-то неправильно ОЧЕНЬ приветствую ваши замечания т.к. если чесно, очень стрёмно попортить что-то в стеке
va_prev(ap, type)	
	#define va_prev(ap, type) (*(type _FAR *)(((*(char _FAR *_FAR *)&
		(ap))-=((sizeof(type)+1) & 0xFFFE))-(((sizeof(type)+1) & 0xFFFE))))

[waleri]

Сообщение от stranger84

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

Вы накропали не менее тяжеловесную функцию. Даже если вы будете печатать только int все равно будет компилироваться *все* - поддрежка float и т.д. - вот отсюдя и идет тяжеловесность таких функций.

Судя по тому, что вы изпользуете std::cout значит у вас С++ - вы будете смеятся, но на С++ можно сделать не более тяжеловесный код, который зато будет typesafe и в некоторых случаях (когда нужны не все типы данных) менее тяжеловесным.

[stranger84]

to waleri не совсем так. первоначально я писал функцию под Visual Studio и там же её отлаживал (соотв нужен был терминал и void main). а потом готовую и "отлаженную" функцию впихнул в IAR.