Функции с переменным числом параметров»
Федеральное агентство по образованию
ГОУ ВПО Уральский Федеральный Университет
Имени первого президента России Б.Н.Ельцина
Кафедра «Вычислительная техника»
Дисциплина: технология программирования
Курсовой проект
Руководитель:
Томашевич В.Г.
Исполнитель:
Студент гр. Фт-290801
Евтух М.И.
Екатеринбург 2011 г.
ОГЛАВЛЕНИЕ
1. Лабораторная работа №1 «Знакомство с Си++. Выполнение программы простой структуры»……………………………….……….4
1.1. Постановка задачи……………………….…….………………….4
1.2. Программа решения задания 1……………………………… …..4
1.3. Результаты работы программы.…..……………………………..5
1.4. Объяснение результатов……………..……………………………5
1.5. Программа решения задания …………………………………….5
1.6. Результаты работы программы……...…………………………..6
1.7. Объяснение результатов…………..………………………………6
2. Лабораторная работа №2 «Использование основных операторов языка Си»………………………………………………………………...7
2.1. Постановка задачи………………………………………………...7
2.2. Текст программы………………………………………………….7
2.3. Результат работы программы…………………………………….7
3. Лабораторная работа №3 «Вычисление функций с использованием их разложения в степенной ряд»………………………………………......8
3.1. Постановка задачи………………………………………………..8
|
|
|
3.2. Текст программы………………………………………………….8
3.3. Результат работы программы…………………………………...10
4. Лабораторная работа №4 «Работа с одномерными массивами»
4.1. Постановка задачи……………………………………………….11
4.2. Текст программы………………………………………………...11
4.3. Результат работы программы…………………………………...14
5. Лабораторная работа №5 «Функции и массивы»
5.1. Постановка задачи……………………………………………….15
5.2. Текст программы………………………………………………...15
5.3. Результат работы программы…………………………………...18
6. Лабораторная работа №6 «Строки»…………………………………...19
6.1. Постановка задачи……………………………………………….19
6.2. Текст программы………………………………………………...19
6.3. Результат работы программы…………………………………...21
7. Лабораторная работа №7.1 «Перегрузка функций в Си++»…………22
7.1. Постановка задачи……………………………………………….22
7.2. Текст программы………………………………………………...22
7.3. Результат работы программы…………………………………...24
8. Лабораторная работа №7.2 «Функции с переменным числом параметров»…………………………………………………………….25
8.1. Постановка задачи……………………………………………….25
|
|
|
8.2. Текст программы………………………………………………...25
8.3. Результат работы программы…………………………………...26
9. Лабораторная работа №8 «Блоковый ввод-вывод»…………………..27
9.1. Постановка задачи……………………………………………….27
9.2. Текст программы………………………………………………...27
9.3. Результат работы программы…………………………………...34
10. Лабораторная работа №9 «Строковый ввод-вывод»………………...36
10.1. Постановка задачи………………………………………………36
10.2. Текст программы………………………………………………..36
10.3. Результат работы программы…………………………………..38
11. Лабораторная работа №10 «Динамические массивы»……………...40
11.1. Постановка задачи………………………………………………40
11.2. Текст программы………………………………………………..40
11.3. Результат работы программы…………………………………..42
12. Лабораторная работа №11 «Информационные динамические структуры»……………………………………………………………...43
12.1. Постановка задачи………………………………………………43
12.2. Текст программы………………………………………………..43
12.3. Результат работы программы…………………………………..49
Лабораторная работа №1
«Знакомство с Си++. Выполнение программы простой структуры.»
Постановка задачи
|
|
|
1. Вычислить значение выражения при различных вещественных типах данных (float и double). Вычисления следует выполнять с использованием промежуточных переменных. Сравнить и объяснить полученные результаты.
2. Вычислить значения выражений. Объяснить полученные результаты.
Программа решения задания 1
#include <iostream.h>
#include <conio.h>
#include <math.h>
int main(int argc, char* argv[])
{
float a,b,c, d, e, f, g, r;
double aa,bb,cc, dd, ee, ff, gg, rr;
int m,n, r1, r2, r3;
aa = 1000;
bb = 0.0001;
a = 1000;
b = 0.0001;
c = pow(a+b,3);
d = pow(a,3);
e = pow(a,2);
f = pow(b,2);
g = pow(b,3);
r = (c-(d+3*e*b))/(3*a*f+g);
cout << "FLOAT: " << r << endl;
cc = pow(aa+bb,3);
dd = pow(aa,3);
ee = pow(aa,2);
ff = pow(bb,2);
gg = pow(bb,3);
rr = (cc-(dd+3*ee*bb))/(3*aa*ff+gg);
cout << "DOUBLE: " << rr << endl;
}
Результаты работы программы для данных типа float
рис.1. Результат работы программы
Объяснение результатов
Так как тип double может содержать более большое число, чем тип float, то вычисление через тип double наиболее точное.
Программа решения задания 2
//---------------------------------------------------------------------------
#include <iostream.h>
|
|
|
#include <conio.h>
#include <math.h>
int main(int argc, char* argv[])
{
m = 5; n = 7;
cout << "\nm = 5\nn = 7\n\n";
r1 = n---m;
cout << "Result n---m: " << r1 << endl;
cout << "m=" << m << endl;
cout << "n=" << n << endl << endl;
r2 = m--<n;
cout << "Result m--<n: " << r2 << endl;
cout << "m=" << m << endl;
cout << "n=" << n << endl << endl;
r3 = n++>m;
cout << "Result n++>m: " << r3 << endl;
cout << "m=" << m << endl;
cout << "n=" << n << endl << endl;
getch ();
return 0;
}
//---------------------------------------------------------------------------
Результаты работы программы
Рис.2. Результат работы программы
Объяснение результатов
Сначала выполняется операция сложения, вычитания и сравнения, а за тем операция «++» или «--».
Лабораторная работа №2
«Использование основных операторов языка Си»
Постановка задачи
Используя оператор цикла, найти сумму элементов, указанных в конкретном варианте. Результат напечатать, снабдив соответствующим заголовком.
Текст программы
#include <iostream.h>
#include <conio.h>
#include <windows.h>
char* rus(const char* text);
int main(int argc, char* argv[])
{
int m;
m = 0;
for (int n = 1; n < 200; )
{
m = n + m;
n = n + 2;
}
cout << rus("Сумма чисел: ") << m;
getch ();
return 0;
}
char bufrus[256];
char* rus(const char* text)
{
CharToOem(text,bufrus);
return bufrus;
}
//---------------------------------------------------------------------------
Результат работы программы
Рис.3. Результат работы программы
Лабораторная работа №3
«Вычисление функций с использованием их разложения в степенной ряд»
Постановка задачи
Для х изменяющегося от a до b с шагом (b-a)/k, где (k=10), вычислить функцию f(x), используя ее разложение в степенной ряд в двух случаях:
а) для заданного n;
б) для заданной точности e (e=0.0001).
Для сравнения найти точное значение функции.
| функция | диапазон изменения аргумента | n | сумма |
| 
| 10 | 
|
Текст программы
#include <iostream.h>
#include <conio.h>
#include <math.h>
#include <iomanip.h>
#include <stdio.h>
#include <windows.h>
char* rus(const char* text);
void func ();
int main(int argc, char* argv[])
{
cout << "Function y = sinX\n" << "0.1<=x<=1\n" << "Step 0.09\n";
cout << rus(" Вычисление...\n");
func ();
getch ();
return 0;
}
char bufrus[256];
char* rus(const char* text)
{
CharToOem(text,bufrus);
return bufrus;
}
void func ()
{
double x = 0.1;
double y = 0;
double w;
double d = 0;
double q=0;
while (x <= 1)
{
double an,s, ann;
int n = 0;
s = 0;
ann = x;
an = x;
q = pow(x, 2);
while (n <= 10)
{
y = (q*an)/(2*n+2);
s = s + y;
an = y;
n++;
}
n = 0;
while(ann > 0.0001)
{
w = (q*ann)/(2*n+2);
d = d + w;
ann = w;
n++;
}
printf(" X= %f", x);
printf(" SN= %f", s);
printf(" SE= %f", d);
printf(" Y= %f\n", sin(x));
x = x + 0.09;
}
}
Результат работы программы
Рис.4. Результат работы программы
Лабораторная работа №4
«Работа с одномерными массивами»
Постановка задачи
1) Сформировать одномерный массив целых чисел, используя датчик случайных чисел.
2) Распечатать полученный массив.
3) Удалить все элементы равные 0.
4) Добавить после первого четного элемента массива элемент со значением M[ I-1 ]+2.
5) Распечатать полученный массив.
Текст программы
#include <iostream.h>
#include <conio.h>
#include <stdio.h>
#include <windows.h>
#include <stdlib.h>
#include <iomanip.h>
/*
1) Сформировать одномерный массив целых чисел, используя датчик случайных чисел.
2) Распечатать полученный массив.
3) Удалить все элементы равные 0.
4) Добавить после первого четного элемента массива элемент со значением M[ I-1 ]+2.
5) Распечатать полученный массив.
*/
class Error {}; //создание пустого класса для обработки ошибок
char* rus(const char* text);
int func1 (int *, int&);
int func2 (int *, int, int&);
int func3 (int *, int, int);
int main(int argc, char* argv[])
{
const int n = 100; //создание массива и задавание его размерности
int m;
int q = 0;
int mas[n];
cout << rus ("1) Введите количество символов в массиве ");
cin >> m;
func1 (mas, m); //заполнение массива случайными числами
cout << "\n[" << setw(5);
for (int i = 0; i < m; i++) //вывод полученного массива
{
cout << *(mas + i) << setw(5);
}
cout << "]";
func2 (mas, m, q); //удаление из массива всех нулей
cout << rus("\t\n\n2) Массив без нулей: \n"); //вывод массива без нулей
cout << "\n[" << setw(5);
for (int i = 0; i < m - q; i++)
{
cout << *(mas + i) << setw(5);
}
cout << "]";
func3 (mas, m, q); //добавление нового элемента
cout << rus("\t\n\n3) Добавление после первого четного элемента массива \t\nэлемент со значением M [I-1]+2: \n");
cout << "\n[" << setw(5);
for (int i = 0; i < m-q+1; i++) //вывод массива с новым элементом
{
cout << *(mas + i) << setw(5);
}
cout << "]";
getch();
return 0;
}
char bufrus[256];
char* rus(const char* text)
{
CharToOem(text,bufrus);
return bufrus;
}
//функция заполнения массива случайными числами
int func1 (int *mas, int& m1)
{
randomize();
try //славливание ошибок в случае
{ //когда пользователь ввел размерность массива
if (m1 > 100) // больше ста
throw Error();
}
catch (Error)
{cerr << "ERROR!\n";}
for (int i = 0; i < m1; i++) //заполнение массива случайными числами
{
mas[i] = random (10);
}
return *mas;
}
//функция удаления нулей из массива
int func2 (int *mas, int m2, int& q1)
{
for (int i = 0; i < m2; i++)
{ //удаление из массива всех нулей
if (mas[i] == 0)
{ //с уменьшением размера массива
q1++;
for (int j = i; j < m2; j++) {
mas[j] = mas[j+1]; //смещение элементов влево
}
}
}
return *mas;
}
//функция добавления нового элемента
int func3 (int *mas, int m3, int q3)
{
for (int i = 0; i < m3 - q3; i++)
{
if (mas[i]%2)
{} //если остатка от деления элемента на два нет
else //то добавляем после этого элемента новый элемент
{
for (int j = m3 - q3; j > i; j--)
{
mas[j] = mas[j-1]; //смещение элементов вправо
}
mas[i+1] = mas[i-1] + 2; //непосредственное добавление элемента
break;
}
}
return *mas;
}
//---------------------------------------------------------------------------
Результат работы программы
Рис.5. Результат работы программы
Лабораторная работа №5
«Функции и массивы»
Постановка задачи
Написать процедуру для суммирования матриц.
С ее помощью сложить исходную матрицу и транспонированную
(т. е. полученную поворотом исходной на 90).
Текст программы
#include <iostream.h>
#include <conio.h>
#include <windows.h>
#include <iomanip.h>
#include <stdio.h>
/*
Написать процедуру для суммирования матриц.
С ее помощью сложить исходную матрицу и транспонированную
(т. е. полученную поворотом исходной на 90).
*/
//объявление прототипов
int** func1 (int **, int **, int);
int** func2 (int **, int **, int **, int);
int** zapol1 (int **, int);
int** zapol2 (int **, int);
int** show (int **, int);
char* rus(const char* text);
int main(int argc, char* argv[])
{
int n;
cout << rus ("\tВведите N: ");
cin >> n; // задание размерности матриц
int **mas1 = new int *[n];
int **mas2 = new int *[n]; //создание матриц
int **mas3 = new int *[n];
zapol1 (mas1, n);
zapol2 (mas2, n); //заполнение матриц
zapol2 (mas3, n);
cout << rus ("\t\n\nВывод матрицы\n");
show (mas1, n); //вывод первой матрицы
func1 (mas1, mas2, n); //транспонирование первой матрицы
cout << rus ("\t\n\nВывод транспонированной матрицы\n");
show (mas2, n); //вывод второй матрицы
func2 (mas1, mas2, mas3, n); //суммирование первой и второй матриц
cout << rus ("\t\n\nВывод суммы матриц\n");
show (mas3, n); //вывод третей матрицы
delete []mas1;
delete []mas2;
delete []mas3;
getch ();
return 0;
}
//русификация программы
char bufrus[256];
char* rus(const char* text)
{
CharToOem(text,bufrus);
return bufrus;
}
//функция вывода матрицы
int** show (int** mas, int n)
{
for (int i = 0; i < n; i++) //вывод заполненного массива
{
cout << "\n[" << setw(5);
for (int j = 0; j < n; j++)
{
cout << mas[i][j] << setw(5);
}
cout << "]\n";
}
return mas;
}
//функция заполнения первой матрицы случайными числами
int** zapol1 (int **mas1, int n)
{
randomize(); //заполнение массива случайными числами
for (int i = 0; i < n; i++)
{
int *temp = new int [n];
for (int j = 0; j < n; j++)
{
temp[j] = random(10);
}
mas1[i] = temp;
}
return mas1;
}
//функция заполнения второй и третей матриц нолями
int** zapol2 (int **mas2, int n)
{
for (int i = 0; i < n; i++)
{
int *temp = new int [n];
for (int j = 0; j < n; j++)
{
temp[j] = 0;
}
mas2[i] = temp;
}
return mas2;
}
//функция транспонирование первой матрицы
int** func1 (int **mas1, int **mas2, int n)
{
for (int i = 0; i < n; i++)
{
for (int j = 0; j < n; j++)
{
mas2[j][i] = mas1[i][j];
}
}
return mas2;
}
//функция суммирование первой и второй матриц
int** func2 (int **mas1, int **mas2, int **mas3, int n)
{
for (int i = 0; i < n; i++)
{
for (int j = 0; j < n; j++)
{
mas3[i][j] = mas1[i][j] + mas2[i][j];
}
}
return mas3;
}
Результат работы программы
Рис.6. Результат работы программы
Лабораторная работа №6
«Строки»
Постановка задачи
Задана строка, состоящая из символов. Символы объединяются в слова. Слова друг от друга отделяются одним или несколькими пробелами. В конце текста ставится точка. Текст содержит не более 255 символов. Выполнить ввод строки, используя функцию Gets(s) и напечатать все слова,
которые не содержат гласных букв.
Текст программы
#include <iostream.h>
#include <conio.h>
#include <windows.h>
#include <stdio.h>
#include <cstring>
/*Напечатать все слова,
которые не содержат гласных букв.*/
//прототип функции проверки слов в строке на наличие гласных
char* prov (char*, char*);
char* rus(const char* text);
int main(int argc, char* argv[])
{
const int size = 255; //задание размера строк
char str [size]; //создание двух строк
char str2 [size];
cout << rus ("Введите строку: ");
gets (str); //ввод первой строки
prov (str, str2); //обработка строк
cout << rus ("Полученная строка: ") << str2; //вывод второй строки
getch();
return 0;
}
char bufrus[256];
//функция русификации программы
char* rus(const char* text)
{
CharToOem(text,bufrus);
return bufrus;
}
//функция проверки слов в строке на наличие гласных
char* prov (char* str, char* str2)
{
const int size = 255; //задаем размер строк
char str1 [size]; //создаем дополнительную строку
int i = 0, y = 0; //в которую будем копировать слова
int q = strlen(str);
for (int s = 0; s <= q+1; s++) //заполняем доп. строку нулями
str1[s] = '\0';
while (i < q)
{
int j, k, w, t;
if (str[i] != ' ')
{
j = i;
while ((str[j] != ' ') && (str[j] != '\0'))
{
str1 [j] = str [j]; //копируем слово из основной строки
j++; //в доп. строку
}
}
str1[j] = ' ';
w = strlen(str1); //определяем длину доп. строки
t = 0;
for (k = i; k < w; k++) //запускаем проверку на наличие гласных
{ //в слове, скопированном в доп. строку
int key = str1[k];
if ((key == -29)||(key == -91)||(key == -21)||(key == -96)||(key == -82)
||(key == -19)||(key == -17)||(key == -88)||(key == -18))
t++;
}
if (t == 0) //если гласных в доп. строке нет,
for (k = i; k < w; k++) //то копируем ее во вторую строку
{ //которую в дальнейшем выведем на экран
str2[y] = str1[k];
y++;
}
i = j;
i++;
}
str2[y] = '\0';
return str2;
}
//---------------------------------------------------------------------------
Результат работы программы
Рис.7. Результат работы программы
Лабораторная работа №7.1
«Перегрузка функций в Си++»
Постановка задачи
Написать перегруженные функции и основную программу, которая их вызывает.
а) для умножения целых чисел;
б) для умножения комплексных чисел.
Текст программы
#include <iostream.h>
#include <conio.h>
#include <windows.h>
/*7.1
Написать перегруженные функции и основную программу, которая их вызывает.
а) для умножения целых чисел;
б) для умножения комплексных чисел.*/
int mult (int, int);
void mult (int [2], int [2]);
int sum (int n, ...);
char* rus(const char* text);
int main(int argc, char* argv[])
{
int a, b, x; //создание целых чисел
int mas1[2], mas2[2]; //создание массивов
while (x != 0)
{
cout << rus ("\nВыберите действие:\n1 - умножение целых чисел\n2 - умножение комплексных чисел\n0-Выход из программы\n ");
cin >> x;
if (x == 1)
{
cout << rus("\n\nВведите первое целое число: ");
cin >> a; //ввод первого числа
cout << rus("Введите второе целое число: ");
cin >> b; //ввод второго числа
cout << rus ("Результат: ") << mult(a, b); //вывод результата
}
else if ( x == 2)
{
cout << rus("\n\nВведите через запятую вещественную \nи мнимую часть первого комплексного числа: ");
scanf ("%d, %d", &mas1[1], &mas1[2]); //ввод первого массива
cout << rus("\nВведите через запятую вещественную \nи мнимую часть второго комплексного числа: ");
scanf ("%d, %d", &mas2[1], &mas2[2]); //ввод второго массива
mult(mas1, mas2); //результат
}
}
getch();
return 0;
}
//русификация программы
char bufrus[256];
char* rus(const char* text)
{
CharToOem(text,bufrus);
return bufrus;
}
//функция умножения целых чисел
int mult (int a, int b)
{
return a*b; //возвращение результата умножения целых чисел
}
//функция умножения комплексных чисел
void mult (int mas1[2], int mas2[2])
{
int q, w, e, r, t, y; //создание дополнительных переменных
q = mas1[1]*mas2[2]; //для хранения ппромежуточной информации
w = mas1[2]*mas2[2];
e = mas1[2]*mas2[1];
r = mas1[1]*mas2[2];
t = q - w;
y = e - r;
if (y < 0) //вывод результата в случае отрицательной мнимой части
printf (rus("\nРезультат: %d%d*i"), t, y);
else //вывод результата в случае положительной мнимой части
printf (rus("\nРезультат: %d+%d*i"), t, y);
}
Результат работы программы
Рис.8. Результат работы программы
Лабораторная работа №7.2
Функции с переменным числом параметров»
Постановка задачи
Написать функцию sum с переменным числом параметров, которая находит сумму чисел типа int по формуле: S=a1*a2+a2*a3+a3*a4+. . . . .
Написать вызывающую функцию main, которая обращается к функции sum не менее трех раз с количеством параметров 5, 10, 12.
Текст программы
#include <iostream.h>
#include <conio.h>
#include <windows.h>
/*7.2.
Написать функцию sum с переменным числом параметров,
которая находит сумму чисел типа int по формуле:
S=a1*a2+a2*a3+a3*a4+. . . . .
Написать вызывающую функцию main,
которая обращается к функции sum не менее трех раз
с количеством параметров 5, 10, 12.*/
int mult (int, int);
void mult (int [2], int [2]);
int sum (int n, ...);
char* rus(const char* text);
int main(int argc, char* argv[])
{
while (x != 0)
{
cout << rus ("\nВыберите действие: \n3 - сумма целых чисел\n0-Выход из программы\n ");
cin >> x;
if (x == 3)
{
cout << rus("\n\nСумма пяти элементов:\n 1+5+7+15+10 = ")<< sum(5, 1,5,7,15,10);
cout << rus("\n\nСумма десяти элементов:\n 1+5+7+15+10+11+3+9+4+20 = ")<< sum(10, 1,5,7,15,10,11,3,9,4,20);
cout << rus("\n\nСумма двенадцати элементов:\n 1+5+7+15+10+11+3+9+4+20+12+2 = ")<< sum(12, 1,5,7,15,10,11,3,9,4,20,12,2);
}
}
getch();
return 0;
}
//русификация программы
char bufrus[256];
char* rus(const char* text)
{
CharToOem(text,bufrus);
return bufrus;
}
//функция суммирования с переменным числом параметров
int sum (int n, ...)
{
int *p = &n; //настраиваем указатель на количество элементов
int sum = 0;
for ( ; n != 0; n--)
sum+=*(++p);
return sum;
}
Результат работы программы
Рис.9. Результат работы программы
Лабораторная работа №8
«Блоковый ввод-вывод»
Постановка задачи
Сформировать двоичный файл из элементов, заданной в варианте структуры, распечатать его содержимое. Формирование, печать, добавление и удаление элементов оформить в виде функций. Предусмотреть сообщения об ошибках при открытии файла и выполнении операций ввода/вывода.
1. Структура "Государство":
- название;
- столица;
- численность населения;
- занимаемая площадь.
Удалить все элементы, у которых численность меньше заданной, добавить элемент после элемента с указанным номером.
Текст программы
#include <iostream.h>
#include <conio.h>
#include <windows.h>
#include <stdio.h>
#include <fstream>
#include <iomanip.h>
/*Структура "Государство":
- название;
- столица;
- численность населения;
- занимаемая площадь.
Удалить все элементы,
у которых численность меньше заданной,
добавить элемент после элемента с указанным номером.*/
struct state //структура Государство
{ //создаем переменные
char name[25]; //содержит название государства
char capital[25]; //содержит название столицы
float number; //численность населения
float area; //площадь государства
};
//прототипы функций
int write1 (FILE *, state *); //запись в первый Файл
int write2 (FILE *, FILE *, state *,int); //запись отобранных данных во второй файл
int read1 (FILE *, state *,int); //чтение первого файла
int add (FILE *, state *,int); //добавление записи во второй файл и чтение его
int save (FILE *, FILE *, FILE *, state *,int);
int load (FILE *, FILE *, state *,int);
char* rus(const char* text);
int main(int argc, char* argv[])
{
FILE *f1; //указатель на начало первого файла
FILE *f2; //указатель на начало второго файла
state mas[10]; //создание массива структуры Государство
FILE *f3;
int q;
int n;
cout << rus("\t\t1 - загрузить список из файла\n\t\t2 - ввести список с экрана: ");
cin >> q;
if (q == 1)
{
f3 = fopen("fff.txt", "r"); //открываем файл, в котором записан счетчик
char buf [100]; //создаем буферную строку
fscanf(f3, "%s", buf); //считываем в буферную строку счетчик
n =atoi(buf); //записываем его в число
fclose(f3); //закрываем файл
n = read1 (f1, mas, n); //чтение первого файла
n = write2 (f1, f2, mas,n); //запись во второй файл
n = add (f2, mas,n); //добавление записи во второй файл и чтение его
n = save (f2, f1, f3, mas, n); //сохранение обработанного списка в первый файл
}
else if (q == 2)
{
n = write1 (f1, mas); //запись в первый Файл
n = read1 (f1, mas,n); //чтение первого файла
n = write2 (f1, f2, mas,n); //запись во второй файл
n = add (f2, mas,n); //добавление записи во второй файл и чтение его
n = save (f2, f1, f3, mas,n); //сохранение обработанного списка в третий файл
}
getch();
return 0;
}
char bufrus[256];
//русификация программы
char* rus(const char* text)
{
CharToOem(text,bufrus);
return bufrus;
}
//фукнция записи данных в первый файл
int write1 (FILE *f1, state *mas)
{
int i;
f1 = fopen("f.txt", "wb"); //открытие первого файла
if (f1 == NULL) //если при открытии возникает ошибка
exit(1);
int m =5; //то выходим из функции
for(i=0; i < m; i++) //ввод данных с экрана
{ //и запись их в первый файл
printf("%s #%i ",rus("Название государства "), i+1);
scanf("%s",&mas[i].name);
printf("%s #%i ",rus("Столица государства: "), i+1);
scanf("%s",&mas[i].capital);
printf("%s #%i ",rus("Численность населения: "), i+1);
scanf("%f",&mas[i].number);
printf("%s #%i ",rus("Занимаемая площадь: "), i+1);
scanf("%f",&mas[i].area);
fwrite(&mas[i], sizeof(state),1,f1);
}
fclose(f1); //закрытие первого файла
clrscr();
return m; //очистка экрана
}
//функция чтения первого файла
int read1 (FILE *f1, state *mas, int m)
{
int i;
f1 = fopen("f.txt", "rb"); //открытие первого файла
if (f1 == NULL) // если при открытии возникает
exit(2); //ошибка, то выходим из функции
i=0;
while(!feof(f1) && i<m) //считывание первого файла в массив
{
fread (&mas[i], sizeof(state),1,f1);
i++;
}
fclose(f1); //закрытие первого файла
for (i = 0; i < m; i++) //вывод данных из первого файла на экран
{
cout << rus("Название государства ")<< i+1 << setw(5) << mas[i].name;
cout << rus("\tСтолица государства ")<< i+1 << setw(10) << mas[i].capital << endl;
cout << rus("Численность населения ") << i+1 << setw(5) << mas[i].number;
cout << rus("\tЗанимаемая площадь ")<< i+1 << setw(10) << mas[i].area << endl << endl;
}
return m;
}
//функция записи отобранных данных во второй файл
int write2 (FILE *f1, FILE *f2, state *mas,int m)
{
float n;
int i = 0;
cout << rus("\nВведите площадь меньше которой надо удалить запись:");
cin >> n; //ввод площади (условие отбора данных)
f1 = fopen("f.txt", "rb"); //открытие первого файла
while(!feof(f1) && i<m) //считывание первого файла в массив
{
fread (&mas[i], sizeof(state),1,f1);
i++;
} //закрытие первого файла
fclose(f1);
clrscr(); //очистка экрана
f2 = fopen ("ff.txt", "wb"); //открытие второго Файла
int f =m;
for (i = 0; i < f; i++) //запись данных
{ //удовлетворяющих условию отбора
if (mas[i].area >= n) //во второй файл и вывод их на экран
{
cout << rus("\nНазвание государства ")<< i+1 << setw(10) << mas[i].name;
cout << rus("\tСтолица государства ")<< i+1 << setw(10)<< mas[i].capital << endl;
cout << rus("Численность населения ")<< i+1 << setw(10) << mas[i].number;
cout << rus("\tЗанимаемая площадь ")<< i+1 << setw(10) << mas[i].area << endl << endl;
fwrite(&mas[i], sizeof(state),1,f2);
}
else
m--;
}
fclose(f2); //закрытие второго файла
return m;
}
//функция добавления данных во второй файл
int add (FILE *f2, state *mas,int m)
{
int n, i;
cout << rus("\nВведите позицию, после которой хотите добавить запись: ");
cin >> n; //ввод позиции, на которую будет добавлена запись
f2 = fopen("ff.txt", "rb"); //открытие второго файла
if (f2 == NULL) // если при открытии файла возникает
exit(4); //ошибка, то выходим из функции
i=0;
while(!feof(f2) && i<m) //считывание второго файла в массив
{
fread (&mas[i], sizeof(state),1,f2);
i++;
}
fclose(f2); //закрытие второго файла
i--;
for ( ; i > n-1; i--) //сдвиг элементов массива
{ //для освобождение позиции
mas[i+1] = mas[i]; //для новой записи
}
m++;
printf(rus("Название государства: ")); //добавление новой записи
scanf("%s",&mas[n].name); //в массив
printf(rus("Столица государства: "));
scanf("%s",&mas[n].capital);
printf(rus("Численность населения: "));
scanf("%f",&mas[n].number);
printf(rus("Занимаемая площадь: "));
scanf("%f",&mas[n].area);
f2 = fopen ("ff.txt", "wb"); //открытие второго Файла
for (i = 0; i < m; i++) //запись данных
{
cout << rus("\nНазвание государства: ") << setw(10) << mas[i].name;
cout << rus("\tСтолица государства:") << setw(10)<< mas[i].capital << endl;
cout << rus("Численность населения:") << setw(10) << mas[i].number;
cout << rus("\tЗанимаемая площадь:") << setw(10) << mas[i].area << endl << endl;
fwrite(&mas[i], sizeof(state),1,f2);
}
fclose(f2);
f2 = fopen("ff.txt", "rb"); //открытие второго файла
if (f2 == NULL) //если при открытии возникает ошибка
exit(1); //то выходим из функции
i=0;
while(!feof(f2) && i<m) //считывание второго файла в массив
{
fread (&mas[i], sizeof(state),1,f2);
i++;
}
fclose(f2); //закрытие второго файла
clrscr(); //очистка экрана
for (i = 0; i < m; i++) //вывод данных из второго файла на экран
{
cout << rus("\nНазвание государства: ") << setw(10) << mas[i].name;
cout << rus("\tСтолица государства:") << setw(10) << mas[i].capital << endl;
cout << rus("\tЧисленность населения:") << setw(10) << mas[i].number;
cout << rus("\tЗанимаемая площадь:") << setw(10) << mas[i].area << endl << endl;
}
return m;
}
//функция сохранения списка в первый файл
int save (FILE *f2, FILE *f1,FILE *f3, state *mas,int m)
{
int i;
f2 = fopen("ff.txt", "rb"); //открытие второго файла
if (f2 == NULL) //если при открытии возникает ошибка
exit(1); //то выходим из функции
i = 0;
while(!feof(f2)&& i<m) //считывание второго файла в массив
{
fread (&mas[i], sizeof(state),1,f2);
i++;
}
fclose(f2); //закрытие второго файла
f1 = fopen("f.txt", "wb"); //открытие первого файла
if (f1 == NULL) //если при открытии возникает ошибка
exit(2); //то выходим из функции
for(i = 0; i < m; i++) //ввод данных с экрана
{ /* //и запись их в первый файл
printf(rus("Название государства: %s"), mas[i].name);
printf(rus("Столица государства: %s"), mas[i].capital);
printf(rus("Численность населения: %f"), mas[i].number);
printf(rus("Занимаемая площадь: %f"), mas[i].area);
*/
fwrite(&mas[i], sizeof(state),1,f1);
}
fclose(f1); //закрытие первого файла
f3 = fopen("fff.txt", "w");
fprintf(f3, "%i", m);
fclose(f3);
return m;
}
Результат работы программы
Рис.10. Загрузка данных из файла и удаление государств с меньшей площадью
Рис.11. Добавление новой записи и результат удаления
Рис.12. Результат работы программы
Лабораторная работа №9
Строковый ввод-вывод»
10.1. Постановка задачи
1. Создать текстовый файл F1 не менее,
чем из 10 строк и записать в него информацию.
2. Задание варианта:
1) Скопировать в файл F2 только те строки из F1,
которые начинаются и заканчиваются на одну и ту же букву.
2) Подсчитать количество символов в F2.
Текст программы
#include <windows.h>
#include <iostream.h>
#include <conio.h>
#include <fstream>
#include <stdio.h>
#include <iomanip.h>
/*
1. Создать текстовый файл F1 не менее,
чем из 10 строк и записать в него информацию.
2. Задание варианта:
1) Скопировать в файл F2 только те строки из F1,
которые начинаются и заканчиваются на одну и ту же букву.
2) Подсчитать количество символов в F2.
*/
char* rus(const char* text);
int main(int argc, char* argv[])
{
FILE *f1; //создаем указатели на файлы
FILE *f2;
int i, s;
const int msize = 255; //создаем буферную строку заданного размера
char buf[msize];
f1 = fopen ("f1.txt","w"); //открываем файл
for(int i=0; i<10 ;i++) //и записываем в него строки
{
cout << rus("Введите строку№ ") << i+1 << endl;
cin >> buf;
buf[strlen(buf)] = '\n';
fprintf(f1,buf);
}
fclose (f1);
f1 = fopen ("f1.txt", "r"); //открываем первый файл для чтения
f2 = fopen ("f2.txt", "w"); //открываем второй файл для записи
while (fgets (buf, 255, f1) != NULL)
{ //пока не конец первого файла
int len = 0, key1 = 0, key2 = 0; //проверяем совпадают ли первая
len = strlen(buf); //и последняя буква строки
key1 = buf[0];
key2 = buf[len-2];
if (key1 == key2) //если да, то копируем строку
{ //во второй файл
fputs(buf, f2);
}
}
fclose(f2);
fclose(f1);
clrscr();
s = 0;
f2 = fopen ("f2.txt","r");
while(fgets (buf, msize, f2) != NULL)
{
printf (buf); //выводим второй файл на экран
s = strlen(buf) + s - 1; //считаем количество символов
} //через длину строки
fclose(f2);
cout << rus("\tСчет: ") << s;
getch();
return 0;
}
char bufrus[256];
char* rus(const char* text)
{
CharToOem(text,bufrus);
return bufrus;
}
//---------------------------------------------------------------------------
10.3. Результат работы программы
Рис.13. Ввод данных
Рис.14. Результат работы программы
Рис.15. Текстовый файл F1.txt Рис.16. Текстовый файл F2.txt
11. Лабораторная работа №10
«Динамические массивы»
Постановка задачи
Сформировать одномерный динамический массив. Удалить из него К элементов, начиная с заданного номера, добавить элемент с заданным ключом
Текст программы
#include <windows.h>
#include <iostream.h>
#include <conio.h>
#include <time.h>
/*
1. Ввести размер массива;
2.Сформировать массив с помощью операции new или библиотечных функций malloc (calloc);
3.Заполнить массив (можно с помощью датчика случайных чисел);
4.Выполнить задание варианта, сформировать новый массив(ы)-результат(ы);
5.Напечатать массив(ы)-результат(ы);
6.Удалить динамические массивы с помощью операции delete или библиотечной функции free.
3. Сформировать одномерный массив.
Удалить из него К элементов, начиная с заданного номера,
добавить элемент с заданным ключом
*/
void print(int *mas, int n);
int *del(int *mas,int n,int k, int m);
char* rus(const char* text);
int main()
{
srand(time(NULL));
int *mas; //создаем массив
cout << rus("Введите размер массива: ");
int n; //задаем размерность массива
cin >> n;
mas = new int[n]; //выделяем память под массив
for(int i=0; i<n; i++) //заполняем массив случайными числами
mas[i] = rand()%20;
print(mas,n); //распечатываем массив
int k,m;
cout << rus("\nВведите позицию: ");
cin >> k; //получаем позицию
cout << rus("Введите количество элементов: ");
cin >> m; //и количество элементов
int *bud = new int[n-m]; //создаем буферный массив
bud = del(mas,n,k,m); //записываем в него массив после удаления
n -= m; //элементов и распечатываем его
print(bud,n);
cout << rus("\nВведите ключ: ");
cin >> k; //получаем ключ (значение элемента)
int *bad = new int[n+1]; //создаем массив
for(int i =0; i<n;i++) //и копируем в него буферный массив
bad[i] = bud[i];
bad[n] = k; //добавляем в конец новый элемент
print(bad,n+1); //распечатываем полученный массив
getch();
return 0;
}
//русификация программы
char bufrus[256];
char* rus(const char* text)
{
CharToOem(text,bufrus);
return bufrus;
}
//функция распечатки массива
void print(int *mas, int n)
{
for (int i = 0; i < n; i++) //выводим массив на экран поэлементно
cout << rus("Элемент№ ") << i+1<< " " << mas[i] << endl;
}
//функция удаления элементов из массива
int *del(int *mas,int n,int k, int m)
{
if(k+m-1 > n) //если сумма номера позиции
{ //и количества элементов больше
cout << "ERROR\n"; //размерности массива
return 0; //то выводим ошибку
}
int *buf = new int[n-m]; //создаем буферный массив
for(int i=0; i<k-1; i++) //копируем в него элементы из исходного
{ //до k-той позиции
buf[i] = mas[i];
}
for(int i=k+m-1; i<n; i++) //начиная с k-той позиции
{ //копируем в буферный массив
buf[i-m] = mas[i]; //остальные элементы
}
return buf;
}
Результат работы программы
Рис.17. Результат работы программы
12. Лабораторная работа №11
«Информационные динамические структуры»
Постановка задачи
Написать программу, в которой создаются динамические структуры. Записи в линейном списке содержат ключевое поле типа int. Сформировать однонаправленный список. Удалить из него К элементов, начиная с заданного номера, добавить элемент перед элементом с заданным ключом.
Разработать следующие функции:
1. Создание списка.
2. Добавление элемента в список (в соответствии со своим вариантом).
3. Удаление элемента из списка (в соответствии со своим вариантом).
4. Печать списка.
5. Запись списка в файл.
6. Уничтожение списка.
7. Восстановление списка из файла.
Текст программы
#include <windows.h>
#include <time.h>
#include <iostream.h>
#include <conio.h>
#include <fstream.h>
/*
1. Написать функцию для создания списка. Функция может
создавать пустой список, а затем добавлять в него элементы.
2. Написать функцию для печати списка. Функция должна предусматривать
вывод сообщения, если список пустой.
3. Написать функции для удаления и добавления элементов списка в
соответствии со своим вариантом.
4. Выполнить изменения в списке и печать списка после каждого изменения.
5. Написать функцию для записи списка в файл.
6. Написать функцию для уничтожения списка.
7. Записать список в файл, уничтожить его и выполнить печать
(при печати должно быть выдано сообщение "Список пустой").
8. Написать функцию для восстановления списка из файла.
9. Восстановить список и распечатать его.
10. Уничтожить список.
3. Записи в линейном списке содержат ключевое поле типа int.
Сформировать однонаправленный список. Удалить из него К элементов,
начиная с заданного номера, добавить элемент перед элементом
с заданным ключом;
*/
//создаем структуру
struct list
{
int num;
list* next;
};
//создаем класс
class dlist
{
private:
list *first;
public:
dlist(int n);
void push(int num);
int print();
int del(int n,int);
void add(int k);
int put_to_file();
void read_from_file();
void del_list();
};
char* rus(const char* text);
int main(int argc, char* argv[])
{
dlist clist(5);
clist.print();
int k,m;
cout << rus("Введите номер элемента, который необходимо удалить\n");
cin >> k >> m;
clist.del(k,m);
cout << rus("Введите кk.x, которые необходимо добавить\n");
cin >> k;
clist.add(k);
clist.put_to_file();
clist.del_list();
clist.print();
clist.read_from_file();
clist.del_list();
getch();
return 0;
}
//русификация программы
char bufrus[256];
char* rus(const char* text)
{
CharToOem(text,bufrus);
return bufrus;
}
//Добавляет элемент в конец списка
void dlist::push(int num)
{
list *buf = new list;
buf->num = num;
if(first == NULL)
{
first = buf;
buf->next = NULL;
}
else
{
list *q;
q = first;
while(q->next != NULL)
q = q->next;
q->next = buf;
buf->next = NULL;
}
}
// Создает список
dlist::dlist(int n)
{
first = NULL;
srand(time(NULL));
for(int i=0; i<n; i++)
push(rand()%9);
}
//удаление элементов
int dlist::del(int k, int m)
{
list *current;
current = first;
for(int i = 1; i<k-1; i++)
{
if(current->next == NULL)
{
cout << rus("В списке меньше ") << k;
cout << rus(" элементов\n");
return -1;
}
current = current->next;
}
list *buf;
buf = current;
for(int i = 0; i<m; i++)
{
if(buf->next == NULL)
{
cout << rus("В списке меньше ") << k;
cout << rus(" элементов\n");
return -1;
}
buf = buf->next;
}
if(k==1)
first = buf->next;
else
current->next = buf->next;
print();
return 0;
}
// Добавляет элемент перед элементом с заданным ключем
void dlist::add(int k)
{
srand(time(NULL));
list *current;
current = first;
while(current->next->num != k)
{
if(current->next == NULL)
cout << "Tupaya pizda";
current = current->next;
}
list *buf = new list;
buf->num = rand()%9;
buf->next = current->next;
current->next = buf;
print();
}
//распечатка списка
int dlist::print()
{
list *current = new list;
current = first;
if(current == NULL)
{
cout << rus("\nСписок пуст!\n");
return -1;
}
int i = 1;
do
{
cout << rus("Элемент номер ") << i << " - ";
cout << current->num << endl;
current = current->next;
i++;
}while(current != NULL);
cout << endl;
return 0;
}
//Печатает список в файл
int dlist::put_to_file()
{
ofstream out("data", ios::out|ios::binary);
if(!out)
{
cout << rus("Не удаётся открыть файл!\n");
return -1;
}
list *current;
current = first;
if(current == NULL)
{
cout << rus("\nСписок пуст!\n");
return -1;
}
do
{
out.write((char *)¤t,sizeof(list));
current = current->next;
}while(current != NULL);
out.close();
}
//Читает список из файла
void dlist::read_from_file()
{
cout << rus("Считываем из файла\n");
first = NULL;
ifstream in("data", ios::in|ios::binary);
while(true)
{
list *current = new list;
in.read((char *)¤t,sizeof(list));
if(in.eof()) break;
push(current->num);
}
in.close();
print();
}
//Удаляет список
void dlist::del_list()
{
cout << rus("\nУдаляем список\n");
list *current = new list;
do{
current = first;
first = first->next;
current = NULL;
}while(first->next!=NULL);
first = NULL;
print();
}
Результат работы программы
Рис.18. Результат работы программы
Рис.19. Вид текстового файла file.txt
Дата добавления: 2018-05-13; просмотров: 646; Мы поможем в написании вашей работы! |
Мы поможем в написании ваших работ!