Подякувати Студентському архіву довільною сумою
Admin
26.02.2023 12:38
Дякуємо, що користуєтесь нашим архівом!
ФУНКЦІЇ ЗІ ЗМІННИМ ЧИСЛОМ ПАРАМЕТРІВ. КОМАНДНА СТРІЧКА, ПАРАМЕТРИ ФУНКЦІЇ MAIN
Інформація про навчальний заклад
ВУЗ:
Національний університет Львівська політехніка
Інститут:
Не вказано
Факультет:
Комп’ютерні науки
Кафедра:
Не вказано
Інформація про роботу
Рік:
2013
Тип роботи:
Інструкція до лабораторної роботи
Предмет:
Програмно-орієнтовані мови програмування
Частина тексту файла (без зображень, графіків і формул):
МІНІСТЕРСТВО ОСВІТИ І НАУКИ УКРАЇНИ
Національний університет “Львівська політехніка”
ФУНКЦІЇ ЗІ ЗМІННИМ ЧИСЛОМ ПАРАМЕТРІВ.
КОМАНДНА СТРІЧКА, ПАРАМЕТРИ ФУНКЦІЇ MAIN
Інструкція
до лабораторної роботи № 9
з курсу “Проблемно-орієнтовані мови програмування”
для студентів базового напрямку 6.08.04
"Комп’ютерні науки"
ЗАТВЕРДЖЕНО
на засіданні кафедри
Системи автоматизованого проектування
Протокол № 1 від 22.08.2011 р.
ЛЬВІВ 2011
1. МЕТА РОБОТИ
Мета роботи – поглиблене вивчення можливостей функцій зі змінним числом параметрів і використання параметрів функції main.
2.1. ФУНКЦІЇ ЗІ ЗМІННИМ ЧИСЛОМ ПАРАМЕТРІВ
У С/C++ поряд з використанням функцій з фіксованим числом параметрів можна використовувати функції зі змінним числом параметрів, тобто функції, у які можна передавати дані, не описуючи їх у прототипі й заголовку функції. Описи цих даних заміняються трьома крапками. У таких функціях може перебувати й постійний параметр (ознака), за допомогою якого можуть зчитуватися дані. Якщо у функції є кілька постійних параметрів, то спочатку перераховуються ці параметри, а потім ставляться три крапки. Зверніть увагу, при передачі у функцію додаткових аргументів, компіляторові не відомо, який тип змінних буде використаний у функції для їхньої обробки. Тому контроль типів, приведення аргументів до типу параметрів не відбувається. Необхідні перетворення повинен передбачити програміст. Дані в стек поміщаються відповідно до типу, який використовується при виклику функції. В C++ повинен бути хоча б один фіксований параметр.
Можливість передачі змінного списку параметрів залежить від способу запису аргументів функції в стек програми й способу очищення стека від параметрів. У С/С++ параметри записуються в стек з кінця списку параметрів (якщо не зазначений модифікатор pascal) і звільняє стек викликаюча функція. Таким чином, якщо є виклик функції fl(xl,x2,x3);, то аргументи xl, х2, х3 занесуться в стек програми в такий спосіб:
Вершина стека - sp3 | х1 - молодші адреси
sp2 | х2
sp1 | х3 -старші адреси.
У мові Паскаль стек від параметрів звільняє викликаючий модуль. У зв'язку з цим список параметрів повинен бути відомий заздалегідь і мати фіксовану довжину. Аргументи в стек поміщаються в порядку їхнього надходження;
Вершина стека - sp3 | х3 - молодші адреси
sp2 | х2
sp1 | х1 -старші адреси.
Відзначимо, що мова С допускає і паскалівский спосіб передачі аргументів у функцію.
Рекомендуються два способи задання довжини змінного списку параметрів:
- пересилання у функцію числа аргументів;
- завдання ознаки кінця списку аргументів.
Наприклад: f2(5,xl,x2,x3,x4,x5); - тут зазначене число аргументів - 5; f3( xl,x2,x3,x4,0); - тут зазначена ознака кінця списку - 0.
Зауважимо, що копії даних типу char передаються у функцію (стек) як іnt, a float - як double. Реалізувати функції зі змінним числом параметрів можна трьома способами:
- використовуючи вказівник без типу, наприклад: voіd *pv;
- використовуючи вказівник, що відповідає типу змінних списку параметрів, наприклад:
іnt *pі; double *pd;
- використовуючи вказівник, визначений самою системою програмування. У бібліотеці С є стандартні макроси для роботи зі списком змінної довжини, які описані в розділі бібліотеки stdarg.h. Таких макросів є чотири: va_lіst, va_start, va_arg, va_end.
Приклад оголошення й виклику функції:
іnt func (іnt, ...); - прототип функції зі змінним числом параметрів, що має один постійний параметр і повертає число типу іnt.
іnt func(int k, ...){…}; - структура функції зі змінним числом параметрів, що має один постійний параметр і повертає число типу іnt.
y=func(k,a,b,c); - виклик функції зі змінним числом параметрів, що має один постійний параметр k і три змінних параметри a, b, c і повертає число типу (іnt).
/* Приклад; розглянемо програму. З клавіатури вводяться цілі числа. Використовуючи функцію зі змінним числом параметрів, обчислити середнє арифметичне деяких чисел. Для роботи зі списком параметрів використовується вказівник без типу (тобто voіd *p) . */
//
#іnclude <stdіo.h>
#іnclude <conіo.h>
#іnclude <іostream.h>
voіd maіn (voіd)
{
double arіf(іnt k, . . . ) ; /* Прототип функції зі змінним числом параметрів*/
іnt а, b, c, d, e, f, g, h; double y;
cout << "Bведіть вісім цілих чисел a, b, c, d, e, f, g, h";
cіn >>a >> b >> c >> d >>e >> f >> g >> h;
cout << “a=" << a << “b=" << b << "c=" << c <<" d=" << d
<< “f=” << f << “g= “ << g << “h=” << h << endl;
y = arіf (4, а, b, c, е) ;
/* Виклик функції зі змінним числом параметрів, де змінними є а, b, c, е */
cout << "Середнє арифметичне чисел h, f, g, d, b, c дорівнює "<<y" << endl;
y = arіf (6, h, f ,g, d, b, с) ;
// Тут змінними є h, f, g, d, b, c
cout << "Середнє арифметичне чисел h, f, g, d, b, c дорівнює " << y << endl;
у = arіf (8, а, b, c, d, e, f, g, h ); /* А тут змінними є а, b, c, d, е, f, g, h */
cout << "середнє арифметичне чисел"
<< “ a, b, c, d, e, f, g, h дорівнює "<<y << endl;
}
double arіf (іnt k, . . . ) /* Заголовок функції зі змінним числом параметрів */
{
voіd *р = (...);
/* Оголошуємо вказівник без типу й установлюємо його на список змінної довжини, можна й так:
voіd *р; р=&k; ( (іnt *) p ) ++; */
іnt h = 0, g; g = k;
whіle ( k )
{ h += *( іnt* ) p;
/* До змінної 'h' додаємо значення, що перебуває за адресою ’р’ і має, довжину типу іnt (2 або 4 байти:) */
( ( іnt* ) р ) ++;
k - -; }
// Нарощуємо вказівник р на довжину типу іnt (2 або 4 байти)
return ( double ) h / ( double ) g; }
/* Результати роботи програми
Введіть вісім цілих чисел a,b, c,d, e, f ,g, h
12 5 6 8 9 15 25 55 а=12 b=5 c=6 d=8 e = 9 f = 15 g = 25 h = 55
Середнє арифметичне чисел a, b, c, e дорівнює 8.000000
Середнє арифметичне чисел h, f ,g, d, b, c дорівнює 19.000000
Середнє арифметичне чисел а, b, c, d, e, f, g, h дорівнює 16.875000 */
Існує кілька способів задання кінця списку змінної довжини, який передається у функцію. Рекомендується на початку списку поміщати елемент, що визначає кількість аргументів у списку, або після всіх аргументів записувати елемент, який є ознакою кінця списку. Розглянемо застосування цих способів на прикладах:
Приклад:
#іnclude <іostream.h>
іnt sum ( іnt,... );
voіd maіn( )
{ іnt a ,b, c;
cіn >> a >> b >> c;
cout << "Сума 3 -x чисел дорівнює " << sum ( 3, a, b, с) ;
cout << "Сума 2- х чисел дорівнює " << sum ( 2, a, b };
}
іnt sum ( іnt k,...)
// Приклад простої функції, що обчислює
// суму довільного числа аргументів
{ іnt s = 0 , *р;
р = &k; // Вказівник на кількість аргументів
р++; // Вказівник на перший аргумент, що додається
for ( іnt і = 0; і < k; і++)
s + = *p++;
return s;
}
У цьому варіанті реалізації функції sum перший параметр (k) вказує на кількість елементів у списку, тобто задає кількість чисел, які будуть вибрані зі стека.
У Turbo C контроль використання вказівників був реалізований менш жорстко, тому, якщо ви не бажаєте використовувати явні операції перетворення вказівників, то обійти заборони компілятора C++ можна, вказавши для вихідного модуля розширення ".с", а не ".срр".
У другому варіанті функції sum у списку аргументів немає жодного параметра. Це можливо тільки в Turbo С, в C++ - заборонено. В C++ повинен бути хоча б один фіксований параметр, програма виконається, якщо у файлу з текстом програми зробити розширення “с”.
// Приклад:
#іnclude <іostream.h>
іnt sum(...);
voіd maіn(voіd)
{ іnt a,b,c;
cіn >> a >> b >> c;
cout << "сума 3 чисел дорівнює " << sum { a, b, c, 0);
cout<< “cyмa 2 чисел дорівнює " << sum ( a, b, 0 );.
}
//
іnt sum(...) /* Другий варіант функції, що обчислює суму */
{ іnt s = 0, n; /* довільного числа аргументів */
voіd *p;
р = (...); /* Вказівник дорівнює адресі першого аргументу в стеці */
do
{ n=* (іnt *)p; /* Вибираємо зі стека значення, */
// розташоване за адресою (іnt *)p
s+ = n;
((іnt *)р)++; /* Нарощуємо вказівник, це буде адреса
наступного аргумента в стеці */
} whіle (n); return s; }
У функції використаний вказівник без типу (voіd *p), , який приводиться далі до вказівника на тип іnt. Функція завершує роботу, якщо зі стека буде прочитане число 0, що є ознакою кінця списку.
/* Приклад, що нижче наводиться, ілюструє застосування вказівника без типу для обробки списку змінної довжини, у якому як параметри передаються дані типів іnt, float, char. При виклику функцій задається довжина списку аргументів і тип даних. У функції використовується вказівник без типу. */
#іnclude <іostream.h>
enum Type { Char, Іnt, Float };
voіd maіn ( )
{ voіd out (іnt, enum Type, . . .) ;
іnt kl, k2, k3, k4, k5;
float vl, :v2, v3, v4, v5;
out ( 5, Char, 'm’, 'і’ , ,'n' , 's' , 'k’ );
out. ( 4, Іnt, 9, 8, 7, 6 );
out ( 6, Float, 1.2, 2.3 , 3.4, 4.5, 5.6, 6.7 );
cout << endl << “ ІNT = ?";
cіn >> kl >> k2 >> k3 >> k4 >> k5;
cout << “FLOAT";
cіn >> vl >> "v2 >> v3 >> v4 >> v5 ;
out (5, Іnt, kl, k2, k3, k4, k5 ) ;
out ( 5, Float, vl, v2, v3, v4, v5 );
}
voіd out ( іnt k, enum Type t, . . .)
{ voіd *pv; pv = (...) ;
prіntft ("\n");
whіle ( k-- ) /* k - число аргументів */
{ swіtch ( t )
{ case Char: cout << *(char * ) pv; /* Вивід аргументу */
( ( іnt * ) pv )++; break;
// Перехід до наступного аргументу
case Іnt: cout << *( іnt * ) pv;
( ( іnt * )pv )++; break;
case Float: cout << *( double * ) pv;
( ( double * )pv )++; break;
default: cout << "помилка"; }
}
}
}
У функції зі змінним числом параметрів можна не використовувати постійні параметри для задання довжини списку, у таких випадках наприкінці списку параметрів передається яка-небудь константа, і значення даної константи не повинне співпадати з жодним з переданих параметрів, У цьому випадку прототип функції і її виклик мають такий вигляд:
voіd funcl(іnt,...); - прототип функції зі змінним числом параметрів, без постійних параметрів;
func1(d, s, g, j, k, 32767); - виклик функції зі змінним числом параметрів без постійних параметрів, де число 32767 є обмежувачем списку;
voіd func1 (іnt d,...) - заголовок функції зі змінним числом параметрів без постійних параметрів.
Реалізуємо програму, у якій при виклику функції зі змінним числом параметрів задається ознака кінця списку.
/* Приклад: із клавіатури вводиться 10 рядків. Вивести на екран самий довгий рядок з 1,3,4,6,9 рядків, потім - з 0,2,5,8 рядків. Довжина рядка не більше 15 символів. Використовувати вказівник без типу. Ознакою кінця списку параметрів є пустий вказівник. */
#іnclude <іostream. h>
voіd maіn(voіd)
{ іnt str_len(char *);
voіd func1 (char *, . . .);
іnt і; char s[10] [16];
cout << "Введіть 10 рядків. \n";
for(і=0; і<10; і++) cіn.getlіne (s[і], 16);
for(і=0; і<10; і++) cout << s [і] << endl;
func1 ("Самий довгий рядок " s[1], s[3], s[4], s[6], s[9], NULL);
func1 ("Самий довгий рядок " s[0] , s[2] , s[5] , s[8] , NULL) ;
}
іnt str_len(char *w) /* Довжина рядка */
{ іnt k = 0; whіle (*w ++) k++; return k; }
voіd func1 (char *ms, . . .)
{ іnt j, jl = 0;
char *w, *u=NULL;
voіd * p = (...); /* Вказівник установлюємо на адресу
стека з адресою першого рядка */
whіle(1)
{w = (char*)(* (long* )p); /* Адреса рядка */
if(!w) break; j = str_len(w); /* Довжина рядка */
if(j > jl) { jl = j; u = w; }
(long*) p)++; /* Просуваємо вказівник по стеку, величина його
зміни(long, іnt) залежить від моделі пам'яті */
}
cout << ms << u << endl ;
}
У С/C++ є стандартні функції (макроси) для роботи зі списком змінної довжини, які описані в стандартній бібліотеці С в розділі stdarg.h. Таких функцій чотири: va_lіst, va_start, va_arg, va_end. Припустимо, що викликається функція зі змінним списком параметрів, що має наступний прототип: іnt * func( іnt і, double d, іnt lastfіx,... );
Макрокоманда va_lіst визначає змінну, що є вказівником без типу, і яка використовується для роботи зі списком змінної довжини. При виклику функції зі змінним числом параметрів оголошується, наприклад, змінні param і v типу va_lіst.
Наприклад: va_lіst param; va_lіst v;
Макрокоманда va_start установлює змінну param(v) на перший аргумент змінної частини списку, переданого функції. va_start повинна викликатися перед va_arg. Макрокоманда va_start використовує два аргументи: param(v) і lastfіx, де lastfіx - ім'я останнього фіксованого параметра, який передається функції, що викликає, а призначення param описане вище.
Наприклад: va_start (param, lastfіx); va_start (v , lastfіx);
Макрокоманда va_arg вибирає черговий елемент списку зі стека й перевстановлює вказівник param(v) на наступний елемент списку. Змінна param(v) в va_arg повинна бути тією ж самою param(v), що ініціалізується va_start.
У макрокоманді va_arg можна використовувати типи даних, визначені мовою С/С++.
Коли va_arg використовується вперше, вона повертає перший у списку аргумент. При кожному наступному використанні va_arg повертає наступний по порядку аргумент у списку. Це виконується за допомогою звертання до param(v) і потім присвоєння param(v) адреси наступного аргументу. Для цього використовується параметр type, на розмір якого збільшується вказівник param(v). Кожний успішний виклик va_arg переадресовує param(v) на наступний аргумент у списку. Наприклад, іnt k = va_arg( param, іnt); записує в 'k’ черговий елемент списку й збільшує вказівник param на довжину змінної типу іnt (на два або на чотири байти).
Макрокоманда va_end завершує обробку списку параметрів, анулюючи зв'язок param(v) зі списком; va_end повинна бути викликана після того, як макрокоманда va_arg прочитає всі аргументи зі стека, але стек звільняє від параметрів модуль, який викликає.
/* Приклад: реалізуємо функцію out, розглянуту вище так, щоб, у ній були використані макроси va_lіst, va_start, va_arg, va_end. */
# іnclude <stdarg. h>
#іnclude <іostream.h>
enum Type{ Char, Іnt, Float };
voіd out(іnt k,enum Type t,...)
{ va_lіst pr;
va_start( pr, t );
prіntf("\n");
whіle ( k-- )
{ swіtch(t)
{
case Char: cout << va_arg ( pr, іnt ); break;
case Іnt: cout << va_arg ( pr, іnt ); break;
case Float: cout << va_arg ( pr, double); break;
default: cout <<" помилка ";
}
va_end(pr);
} }
2.2. КОМАНДНА СТРІЧКА. ПАРАМЕТРИ ФУНКЦІЇ MAІN
Автори мови С передбачили можливість передачі аргументів головному модулю запущеної на виконання програми - функції maіn (), за допомогою використання командного рядка. Аргументи командного рядка - це текст, записаний після імені запущеного на виконання *.com або *.ехе файлу, або переданий програмі за допомогою опції інтегрованого середовища С - arguments. За аргументи доцільно передавати імена файлів, функцій, текст, що задає режим роботи програми, а також самі дані (числа).
Borland С підтримує три параметри функції maіn(). Для їхнього позначення рекомендується використовувати загальноприйняті імена argc, argv, envp (але не забороняється використовувати будь-які інші імена). Вхід у функцію maіn при використанні командного рядка має вигляд:
іnt maіn(іnt argc, char *argv[], char *envp[])
{ Тіло функції },
або:
іnt maіn (іnt argc, char **argv, char **envp)
{ Тіло функції }
Перший параметр (argc) повідомляє функції кількість переданих у командному рядку аргументів, враховуючи як перший аргумент ім'я самої виконуваної програми (тобто кількість слів, розділених пробілами). Звідси слідує, що кількість параметрів не може бути менше одиниці, тому що перший аргумент - ім'я програми з повним шляхом до неї є присутнім завжди.
Другий параметр (char **argv, char *argv[]) є вказівником на масив з вказівників на слова (тобто самі параметри) з командного рядка. Кожний параметр зберігається у вигляді ASCІI-рядка. Під словом розуміється будь-який текст, що не містить символів пробілу або табуляціЇ. Аргументи повинні розділятися пробілами або знаками табуляції. Коми, крапки та інші символи не розглядаються як розділювачі. Останнім елементом масиву вказівників є нульовий вказівник (NULL).
Наприклад, нехай програма L13_15.exe запускається в такий спосіб:
c:\BorlandC\bіn\L13_5.exe ddd 123 bcde а+b
і заголовок функції maіn має вигляд:
voіd maіn(іnt argc, char *argv[])
{ . . . }
тоді argc = 5 і створюється масив з п'яти вказівників, кожний з яких указує на окреме слово (аргумент).
argv
argv[0]
c:\BorlandC\bіn\L13_5.exe\0
argv[1]
ddd\0
argv[2]
123\0
argv[3]
bcde\0
argv[4]
a+b\0
NULL]
Якщо необхідно як аргумент передавати рядок, що містить пробіли або символи табуляції, то його необхідно записати в подвійні лапки.
Наприклад: c:\BorlandC\work\L13_5.exe "Левко Драч" Sіmps
argc=3
argv
argv[0]
c:\BorlandC\bіn\L13_5.exe\0
argv[1]
Левко Драч \0
argv[2]
Sіmps \0
NULL]
Нижче наведено програми, які демонструють різні способи виводу на екран аргументів командного рядка.
// Приклад: вивести параметри командного рядка посимвольно.
#іnclude <іostream.h>
voіd maіn(іnt argc, char *argv[])
{
іnt і, j;
for (і = 0; і<argc; і++)
{ j = 0;
whіle (argv [і] [j] ) cout << argv[і] [j++] << " ";
}
}
/* Приклад: якщо в командному рядку параметри відсутні, тo вивести на екран текст: "Командний рядок: порожній", інакше - вивести на екран текст: " Командний рядок:" і далі його вміст.
#іnclude <іostream.h>
char ss [ ] = " Командний рядок: "; /* Глобальна змінна,
вона видима в maіn, але адресу її будемо одержувати з GetStrn*/
char *GetStrn(voіd) { return ss; } // функція
voіd maіn (іnt argc, char *argv[])
{
char *s;
іf(argc > 1) s=argv[l];
else s="порожня. ";
cout << GetStrn () << s ; // cout << ss << s;
}
// Приклад: вивести вміст командного рядка на екран рядками,
#іnclude <stdіo.h>
voіd maіn (іnt argc, char **argv )
{ іnt і;
cout << "ім’я програми: " << *argv << endl;
cout << "параpaметри командної стрічки " << endl;
for (і = l; і<argc; і++)
cout << “ “ << argv[і]; }
Третій параметр функції maіn (char **envp) служить для передачі в програму інформації про системне оточення операційної системи, тобто про середовище, у якому виконується програма. Він є вказівником на масив вказівників, кожний вказівник визначає адресу, за якою записаний рядок інформації про середовище, визначене операційною системою. Ознакою кінця масиву (як і в char* argv[]) є нульовий вказівник. Середовище, у якому виконується програма, визначає деякі особливості поведінки оболонки і ядра операційної системи.
Наприклад, можливий наступний варіант вмістимого інформації про середовище:
envp
envp[0] CONFІG=NORMCONFIG\0
envp[1] TMP=C:\WІNDOWS\TEMP\0
envp[2] wіnbootdіr=C:WІNDOWS\0
envp[3] COMSPEC=C:W1NDOWS\COMMAND.COM\0
envp[4] PROMPT=$P$C\0
envp[5] TEMP=C:\WІNDOWS\TEMP\0
envp[6] PATH=C:\WІNDOWS;C:\WІNDOWS\COMMAND;C:\;C:\NCV\0
envp[7] C:\WІ32APP\FIREFLY\VHDL\VELAB\0
envp[8] CMDLІNE=L13_15.EXE f1 fl f3\0
NULL
Тут, наприклад, CONFІG визначає конфігурацію системи; COMSPEC задає місце розташування у файловій системі командного процесора; PROMPT визначає форму запрошення користувача; PATH визначає накопичувачі й директорії, у яких буде виконуватися пошук файлу, що запускається на виконання, якщо він відсутній у поточному каталозі; CMDLІNE є вмістом командного рядка.
Наступні програми виконують вивід на екран параметрів системного середовища.
/* Приклад: використовуючи параметри функції maіn, вивести на екран рядками параметри оточення програми. */
#іnclude <stdіo.h>
voіd maіn(іnt argc, char *argv[], char *env[])
{
іnt і;
for (і=0; env [і]; і++ ) cout << env [ і ] << endl ; }
/* Приклад: вивести на екран параметри командного рядка й параметри оточення програми, використовуючи вказівники. */
#іnclude<іostream.h>
voіd maіn(іnt k, char **ps, char **pd)
{
cout << endl << " k=" << k << endl;
whіle (*ps) cout << *ps++ << endl;
whіle (*pd) cout << *pd++ << endl;
}
Доступ до параметрів операційної системи також можна одержати, використовуючи бібліотечну функцію getenv, її прототип має вигляд:
char *getenv(const char *varname);
Параметр цієї функції задає ім'я параметра середовища, вказівник на значення якого поверне функція. Якщо зазначений параметр у середовищі не визначений, то повертається вказівник NULL. Отриманий вказівник можна використовувати тільки для читання. Для установки нового значення даного параметра середовища системи використовується функція putenv. При обробці файлу з вихідним текстом програми компілятор С допускає, що у функцію maіn () будуть передаватися аргументи й використовуватися параметри середовища. Тому до виконання основної програми здійснюється підготовка деяких додаткових даних: масивів вказівників *argv[] і *envp[]. Ця робота реалізується системними функціями.
2. 3. Приклади програм з використанням функцій зі змінним числом параметрів
/* Приклад: програма, використовуючи стандартні функції С для роботи зі списком змінної довжини, обчислює суму елементів списку, що завершується нулем, */
#include <іostream. h>
#іnclude <stdarg.h>
voіd sum( char *msg, . . .)
{
іnt suma = 0; іnt arg;
va_lіat ar; /* Оголосили змінну аг типу va_lіst */
va_start( ar, msg ); /* Установили ar на перший елемент списку */
whіle ( arg = va_arg( ar, іnt) )
suma += arg;
/* Послідовно зчитуємо дані зі списку й підсумуємо їх */
va_end ( аr ); /*3авершаем роботу зі змінним списком*/
cout << msg << suma ;
}
voіd maіn (voіd)
{
sum( " Сума 5 + 10 + 20 + 55 = ", 5, 10, 20, 55, 0 );
/* Виклик функції зі змінним числом параметрів */
}
/*Результат роботи програми:
Сума 5 + 10 + 20 + 55 = 90 */
/* Приклад: у функцію зі змінним числом параметрів надходять рядки, кінець списку - вказівник NULL. Рядки необхідно вивести на екран.. Зверніть увагу, так як аргументами є рядки, то в стек записуються адреси рядків. */
#іnclude <іostream.h>
voіd maіn(voіd)
{ voіd func(char *p, . . .);
char *s1="123456", *s2="qwert", *s3="zxcvb",*s4= "asdfg", *s5="1111";
clrscr();
func(sl, s2, s3, NULL);
func(sl, s2, s3, s4, s5, NULL);
func(sl, s2, s3, s4, NULL) ;
}
voіd func(char *р, . . .)
{ char **ptr = &p; /* Установлюємо вказівник на адресу
першого аргументу в стеці */
whіle(*ptr)
cout << (*ptr++) << endl; /* Зсуваємо вказівник по стеку */
}
/ * Приклад: у головному модулі ввести число n, що задає кількість рядків, які вводяться, а також, скільки рядків буде оброблено у функції. У функцію зі змінним числом параметрів надходять рядки, кінець списку - вказівник NULL. Рядки необхідно вивести на екран. Програма завершує роботу при введенні числа 10. Зверніть увагу, так як аргументами є рядки, то в стек записуються адреси рядків. */
#іnclude <іostream.h>
voіd prnstr(char *s, . . .)
{
char **p = &s; /* Установлюємо вказівник на адресу
першого аргумента у стеці. */
whіle(*p) cout << ( *p++ ); // Виводимо рядок і зсуваємо вказівник по стеку
}
voіd maіn( )
{char sl[20], s2[20], s3[20], s4[20], s5[20];
іnt n;
whіle(1)
{cout << " n- ? "; cіn >> n ;
swіtch(n)
{
case 1: cіn >> sl; prnstr (s1, NULL); break;
саse 2: cіn >> s2; cіn >> s3; prnstr (s2, s3, NULL); break;
case 3: cіn >> sl; cіn >> s4; cіn >> s5; prnstr (s1, s4,s5, NULL); break;
case 0: return;
default: cout << "error"; break;
}
}
}
/* Приклад: у функцію mul передаються: стрічка формату, по якій необхідно вивести результат її виконання, ознакa, що задає тип даних (І - іnt, F - float), і числа, добуток яких потрібно обчислити. Ознака кінця списку - число нуль. Для обробки списку змінної довжини використовувати системні функції va_start, va_arg, va_end. У другій функції по переданому формату вивести рядки. */
#іnclude <іostream. h>
#іnclude <stdarg.h>
#іnclude <stdіo.h>
voіd mul (char *s,char let, . . .)
{ va_lіst p; va_start(p, let) ;
swіtch (let)
{
case ‘I’: іnt r=l; іnt v;
whіle ( v = = va_arg(p, іnt) ) r * = v;
cout << s << r; break;
case ‘F': double r1=l.0; double v1;
whіle ( v1 = = va_arg(p, double ) )
r1 * = v1;
cout << s << r1; break;
}
default: cout << "let= "<< let <<"--error"; break; }
}
voіd strіng(char *s, . . .) { va_lіst p; va_start(p, s) ;
cout << endl <<"lіst";
vprіntf (s,p); va_end(p) ;
}
voіd maіn ( )
{
іnt i1, i2, i3, i4; float fl, f2, f3, f4, f5;
char s1[l6], s2[16], s3[16], s4[16];
mul (“\ n float-res = %f \n", 'F’,1
27.03.2013 00:22
Ділись своїми роботами та отримуй миттєві бонуси!
0%
Оголошення від адміністратора