Часть №7: Практические задания по С++ / Ravesli

Филипп:

1 мая 2023 в 13:19

Задание №2.

#include <iostream>
#include <string>

using namespace std; 

int main()
{
	setlocale(LC_ALL, "rus");
	string input;
	cout << "Введите число: ";
	cin >> input;

	int location = input.find(".");    // местоположение точки-разделителя в массиве
	int i = location + 1;              // порядковый номер элемента с которого проверяем нули

	if (location && (location != string::npos))
	{
		for (i; i < input.size(); i++)
		{
			if (input[i] == '0')
			{
				continue;
			}
			else
			{
				cout << "Не целое";
				break;
			}
		}
		if (input[i] == 0)
		{
			cout << "Целое";
		}
	}
	else
	{
		cout << "Целое";
	}
        return 0;
}

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

#include <iostream>

#include <string>

using namespace std;

int main()

{

setlocale(LC_ALL, "rus");

string input;

cout << "Введите число: ";

cin >> input;

int location = input.find("."); // местоположение точки-разделителя в массиве

int i = location + 1; // порядковый номер элемента с которого проверяем нули

if (location && (location != string::npos))

{

for (i; i < input.size(); i++)

{

if (input[i] == '0')

{

continue;

}

else

{

cout << "Не целое";

break;

}

if (input[i] == 0)

{

cout << "Целое";

}

else

{

cout << "Целое";

}

return 0;

}

Ответить

Finchi:

26 августа 2022 в 12:56

Задание №3:

#include <iostream>
#include <vector>
#include <fstream>
#include <string>
#include <algorithm>
struct Data
{
	std::string name;
	int first;
	int second;
	int third;
	double averange;
};
class StudentsMarks
{
public:
	StudentsMarks()
		: m_size{ list_size() }
	{
		write_vector();
		auto biggest_averange
		{
			[](const Data& a, const Data& b)
			{
				return a.averange > b.averange;
			}
		};
		std::sort(m_vec.begin(), m_vec.end(), biggest_averange);
	}
	void write_list()
	{
		for (auto i : m_vec)
			std::cout << "Имя: " << i.name << "\tОценки: " << i.first << ", " << i.second << ", " << i.third
			<< "\tСредний бал: "<<i.averange<<"\n";
	}
private:
	int m_size; //Не используется
	std::string m_file{ "input_data.txt" };
	int list_size() //Не используется
	{
		std::ifstream file_in(m_file);
		if (file_in.is_open())
		{
			std::string s_size;
			if (std::getline(file_in, s_size))
			{
				file_in.close();
				return std::stoi(s_size);
			}
		}
		file_in.close();
		return -1;
	}
	std::vector<Data> m_vec;
	void write_vector()
	{
		std::ifstream file_in(m_file);
		if (file_in.is_open())
		{
			std::string line;
			std::getline(file_in, line); //Пропускаем первую строку
			while (std::getline(file_in, line))
			{
				std::string temp;
				int space_count = 0;
				Data data;
				for (int i = 0; i < line.length(); i++)
				{
					if (line.at(i) != ' ')
						temp += line.at(i);
					else
					{
						switch (space_count)
						{
						case 0:
							data.name = temp;
							temp.clear();
							break;
						case 1:
							data.name += " " + temp;
							temp.clear();
							break;
						case 2:
							data.first = std::stoi(temp);
							temp.clear();
							break;
						case 3:
							data.second = std::stoi(temp);
							temp.clear();
						case 4:
							break;
						default:
							std::cerr << "Произошла ошибка во время подсчета пробелов\n";
							break;
						}
						space_count++;
					}
				}
				data.third = std::stoi(temp);
				temp.clear();
				m_vec.push_back(data);
			}
			count_and_write_averange();
			file_in.close();
		}
	}
	void count_and_write_averange()
	{
		for (auto &i : m_vec)
		{
			double averange = (static_cast<double>(i.first + i.second + i.third))/ 3;
			i.averange = averange;
		}
	}
};
int main()
{
	setlocale(LC_ALL, "russian");
	StudentsMarks list;
	list.write_list();
	return 0;
}

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

78

79

80

81

82

83

84

85

86

87

88

89

90

91

92

93

94

95

96

97

98

99

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

#include <iostream>

#include <vector>

#include <fstream>

#include <string>

#include <algorithm>

struct Data

{

std::string name;

int first;

int second;

int third;

double averange;

};

class StudentsMarks

{

public:

StudentsMarks()

: m_size{ list_size() }

{

write_vector();

auto biggest_averange

{

[](const Data& a, const Data& b)

{

return a.averange > b.averange;

}

};

std::sort(m_vec.begin(), m_vec.end(), biggest_averange);

}

void write_list()

{

for (auto i : m_vec)

std::cout << "Имя: " << i.name << "\tОценки: " << i.first << ", " << i.second << ", " << i.third

<< "\tСредний бал: "<<i.averange<<"\n";

}

private:

int m_size; //Не используется

std::string m_file{ "input_data.txt" };

int list_size() //Не используется

{

std::ifstream file_in(m_file);

if (file_in.is_open())

{

std::string s_size;

if (std::getline(file_in, s_size))

{

file_in.close();

return std::stoi(s_size);

}

file_in.close();

return -1;

}

std::vector<Data> m_vec;

void write_vector()

{

std::ifstream file_in(m_file);

if (file_in.is_open())

{

std::string line;

std::getline(file_in, line); //Пропускаем первую строку

while (std::getline(file_in, line))

{

std::string temp;

int space_count = 0;

Data data;

for (int i = 0; i < line.length(); i++)

{

if (line.at(i) != ' ')

temp += line.at(i);

else

{

switch (space_count)

{

case 0:

data.name = temp;

temp.clear();

break;

case 1:

data.name += " " + temp;

temp.clear();

break;

case 2:

data.first = std::stoi(temp);

temp.clear();

break;

case 3:

data.second = std::stoi(temp);

temp.clear();

case 4:

break;

default:

std::cerr << "Произошла ошибка во время подсчета пробелов\n";

break;

}

space_count++;

}

data.third = std::stoi(temp);

temp.clear();

m_vec.push_back(data);

}

count_and_write_averange();

file_in.close();

}

void count_and_write_averange()

{

for (auto &i : m_vec)

{

double averange = (static_cast<double>(i.first + i.second + i.third))/ 3;

i.averange = averange;

}

};

int main()

{

setlocale(LC_ALL, "russian");

StudentsMarks list;

list.write_list();

return 0;

}

Ответить

Finchi:

26 августа 2022 в 10:55

Задание №1 для любой ОС с использованием chrono:

#include <iostream>
#include <chrono>
#include <conio.h>
int main()
{
	setlocale(LC_ALL, "russian");
	int GMT = 3;
	
	while (!_kbhit())
	{
		auto time{ std::chrono::system_clock::now() };
		while (time + std::chrono::seconds(1) < std::chrono::system_clock::now());
		time = std::chrono::system_clock::now();
		auto hours{ std::chrono::hours(GMT) + std::chrono::duration_cast<std::chrono::hours>(time.time_since_epoch()) % 24 };
		auto minutes{ std::chrono::duration_cast<std::chrono::minutes>(time.time_since_epoch()) % 60 };
		auto seconds{ std::chrono::duration_cast<std::chrono::seconds>(time.time_since_epoch()) % 60 };
		std::chrono::hh_mm_ss hms{ hours + minutes + seconds};
		std::cout << hms;
		std::cout << "\r";
	}
	return 0;
}

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

#include <iostream>

#include <chrono>

#include <conio.h>

int main()

{

setlocale(LC_ALL, "russian");

int GMT = 3;

while (!_kbhit())

{

auto time{ std::chrono::system_clock::now() };

while (time + std::chrono::seconds(1) < std::chrono::system_clock::now());

time = std::chrono::system_clock::now();

auto hours{ std::chrono::hours(GMT) + std::chrono::duration_cast<std::chrono::hours>(time.time_since_epoch()) % 24 };

auto minutes{ std::chrono::duration_cast<std::chrono::minutes>(time.time_since_epoch()) % 60 };

auto seconds{ std::chrono::duration_cast<std::chrono::seconds>(time.time_since_epoch()) % 60 };

std::chrono::hh_mm_ss hms{ hours + minutes + seconds};

std::cout << hms;

std::cout << "\r";

}

return 0;

}

Ответить

Dmitry:

16 августа 2022 в 14:07

Задание 2.

#include <iostream>
#include <string>
#include <cctype>


using namespace std;

bool cheackIsInt(string& str)
{
    
    for (int i = 0; i < str.size(); i++)
    {
        if (!isdigit(str[i]))
        {
           return false;
        }           
    }
    return true;
}

int main() {
    setlocale(0, "");

    cout << "Введите целое число: ";

    string str;
    getline(cin, str);
        
    if (cheackIsInt(str) == true)
    {
        cout << "Введено целое число.\n";
    }
    else
    {
        cout << "Строка не является целым числом!\n";
    }

    return 0;
}

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

#include <iostream>

#include <string>

#include <cctype>

using namespace std;

bool cheackIsInt(string& str)

{

for (int i = 0; i < str.size(); i++)

{

if (!isdigit(str[i]))

{

return false;

}

return true;

}

int main() {

setlocale(0, "");

cout << "Введите целое число: ";

string str;

getline(cin, str);

if (cheackIsInt(str) == true)

{

cout << "Введено целое число.\n";

}

else

{

cout << "Строка не является целым числом!\n";

}

return 0;

}

Ответить

Og:

7 декабря 2021 в 04:24

//№ 2

#include <iostream>
#include <string>
char mToChar(char ch);
int main()
{
	system("chcp 1251 > nul");
	std::cout << "Введите строку: ";
	std::string x;
	std::cin >> x;
	for (int i{ 0 }; i < x.size(); ++i)
	{
		if (x[i] != mToChar(x[i]))
		{
			std::cout << "строка " << x <<
				" не является целым числом" << '\n';
			break;
		}
		if(i == x.size()-1)
			std::cout << "строка " << x << " является целым числом" << '\n';
	}
	
	system("pause");
}
char mToChar(char ch)
{
	switch (ch)
	{
	case '0': return '0';
	case '1': return '1';
	case '2': return '2';
	case '3': return '3';
	case '4': return '4';
	case '5': return '5';
	case '6': return '6';
	case '7': return '7';
	case '8': return '8';
	case '9': return '9';
	default:
		break;
	}
}

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

#include <iostream>

#include <string>

char mToChar(char ch);

int main()

{

system("chcp 1251 > nul");

std::cout << "Введите строку: ";

std::string x;

std::cin >> x;

for (int i{ 0 }; i < x.size(); ++i)

{

if (x[i] != mToChar(x[i]))

{

std::cout << "строка " << x <<

" не является целым числом" << '\n';

break;

}

if(i == x.size()-1)

std::cout << "строка " << x << " является целым числом" << '\n';

}

system("pause");

}

char mToChar(char ch)

{

switch (ch)

{

case '0': return '0';

case '1': return '1';

case '2': return '2';

case '3': return '3';

case '4': return '4';

case '5': return '5';

case '6': return '6';

case '7': return '7';

case '8': return '8';

case '9': return '9';

default:

break;

}

Ответить

WAR:

13 августа 2021 в 14:17

Задание №1 (доработал появление нулей перед цифрами):

#include <iostream>
#include <windows.h>
#include <ctime>
#include <conio.h>
#include <string>

main() {
    std::cout << "Clock work 03 minutes or until press any key\n\n";
    Sleep(1000);
    SYSTEMTIME locTime;
    int i{0};
    std::string h, m, s;
    while(++i <= 180) {
        GetLocalTime(&locTime);
        h = locTime.wHour < 10 ? "0" + std::to_string(locTime.wHour) :
                                                   std::to_string(locTime.wHour);
        m= locTime.wMinute<10 ? "0"+std::to_string(locTime.wMinute) :
                                                     std::to_string(locTime.wMinute);
        s= locTime.wSecond<10 ? "0"+std::to_string(locTime.wSecond) :
                                                    std::to_string(locTime.wSecond);
        std::cout << "\rThe current time is : " << h << ":" << m << ":" << s << std::flush;
        Sleep(1000);
        if(_kbhit()) break;
    }
    return 0;
}

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

#include <iostream>

#include <windows.h>

#include <ctime>

#include <conio.h>

#include <string>

main() {

std::cout << "Clock work 03 minutes or until press any key\n\n";

Sleep(1000);

SYSTEMTIME locTime;

int i{0};

std::string h, m, s;

while(++i <= 180) {

GetLocalTime(&locTime);

h = locTime.wHour < 10 ? "0" + std::to_string(locTime.wHour) :

std::to_string(locTime.wHour);

m= locTime.wMinute<10 ? "0"+std::to_string(locTime.wMinute) :

std::to_string(locTime.wMinute);

s= locTime.wSecond<10 ? "0"+std::to_string(locTime.wSecond) :

std::to_string(locTime.wSecond);

std::cout << "\rThe current time is : " << h << ":" << m << ":" << s << std::flush;

Sleep(1000);

if(_kbhit()) break;

}

return 0;

}

Ответить

WAR:

13 августа 2021 в 12:10

Задание №1:

#include <iostream>
#include <windows.h>
#include <ctime>
#include <conio.h>

main() {
    std::cout << "Clock work 3 minutes or until press any key\n\n";
    Sleep(1000);
    SYSTEMTIME locTime;
    int i{0};
    while(++i <= 180) {
        GetLocalTime(&locTime);
        std::cout << "\rThe current time is : " << locTime.wHour << ":"
        << locTime.wMinute << ":" << locTime.wSecond << std::flush;
        Sleep(1000);
        if(_kbhit()) break;
    }
    return 0;
}

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

#include <iostream>

#include <windows.h>

#include <ctime>

#include <conio.h>

main() {

std::cout << "Clock work 3 minutes or until press any key\n\n";

Sleep(1000);

SYSTEMTIME locTime;

int i{0};

while(++i <= 180) {

GetLocalTime(&locTime);

std::cout << "\rThe current time is : " << locTime.wHour << ":"

<< locTime.wMinute << ":" << locTime.wSecond << std::flush;

Sleep(1000);

if(_kbhit()) break;

}

return 0;

}

Ответить

WAR:

12 августа 2021 в 18:42

Задание №2:

#include <iostream>
#include <string>
#include <cctype>

void isNumber() {
    std::string str;
    std::cout << "Enter string: ";
    std::getline(std::cin, str);
    bool is_num{true};
    for(char &i : str) {
        if(!isdigit(i)) {is_num = false; break;}
    }
    is_num ? std::cout << str << " is whole number" :
        std::cout << str << " not is whole number";
}

main() {
    isNumber();
    return 0;
}

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

#include <iostream>

#include <string>

#include <cctype>

void isNumber() {

std::string str;

std::cout << "Enter string: ";

std::getline(std::cin, str);

bool is_num{true};

for(char &i : str) {

if(!isdigit(i)) {is_num = false; break;}

}

is_num ? std::cout << str << " is whole number" :

std::cout << str << " not is whole number";

}

main() {

isNumber();

return 0;

}

Ответить

Rock:

13 декабря 2020 в 01:51

Задание 1: Хоть оно и стоит в easy но таковым назвать его трудно ибо программе нужно и выводить часы и ждать ввода пользователя а это в 1 поток не вписывается и потому пришлось изучить многопоточность)

#include<iostream>
#include<thread>
#include<Windows.h>


void Do_time()
{
	int m=0, s=0;

	for (int i = 0;; i++)
	{
		system("cls<NUL");


		if (m < 10)
		{
			if(s<10)
			std::cout << "0" << m << ":0" << s;

			if (s >= 10)
			std::cout << "0" << m << ":" << s;

		}
		
		if (m >= 10)
		{
			if (s < 10)
				std::cout  << m << ":0" << s;

			if (s >= 10)
				std::cout  << m << ":" << s;

		}


		if (s == 59)
		{
			m++;
			s = 0;
		}
		s++;
		Sleep(1000);

		
	}
}

int main()
{
	setlocale(0, "");



	std::thread th(Do_time);
	th.detach();

	system("pause");


	return 0;
}

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

#include<iostream>

#include<thread>

#include<Windows.h>

void Do_time()

{

int m=0, s=0;

for (int i = 0;; i++)

{

system("cls<NUL");

if (m < 10)

{

if(s<10)

std::cout << "0" << m << ":0" << s;

if (s >= 10)

std::cout << "0" << m << ":" << s;

}

if (m >= 10)

{

if (s < 10)

std::cout << m << ":0" << s;

if (s >= 10)

std::cout << m << ":" << s;

}

if (s == 59)

{

m++;

s = 0;

}

s++;

Sleep(1000);

}

int main()

{

setlocale(0, "");

std::thread th(Do_time);

th.detach();

system("pause");

return 0;

}

Задание 2:

#include<iostream>
#include<cctype>

void Integer_Check(std::string& str)
{

	for (int i = 0; i < str.length(); i++)
	{
		if (std::isdigit(str[i]))
			continue;
		std::cout << "Ваше число не целочисленное или не число вовсе!" << std::endl;
		exit(1);
	}
	std::cout << "Ваше число целочисленное!" << std::endl;
}

int main()
{
	setlocale(0, "");

	std::string str;

	std::cout << "Введите число для проверки на целостность - ";
	std::cin >> str;

	Integer_Check(str);

	return 0;
}

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

#include<iostream>

#include<cctype>

void Integer_Check(std::string& str)

{

for (int i = 0; i < str.length(); i++)

{

if (std::isdigit(str[i]))

continue;

std::cout << "Ваше число не целочисленное или не число вовсе!" << std::endl;

exit(1);

}

std::cout << "Ваше число целочисленное!" << std::endl;

}

int main()

{

setlocale(0, "");

std::string str;

std::cout << "Введите число для проверки на целостность - ";

std::cin >> str;

Integer_Check(str);

return 0;

}

Задание 3: стало настоящим испытанием но было достаточно интересно его делать в конце кода в коментах написана одна проблема которую не удалось решить.Если у кого будет желание помочь то буду благодарен!

#include <iostream>
#include <string>
#include <fstream>
#include <cctype>
#include <vector>
#include <iomanip>
#include <sstream>
#include <algorithm>
#include <windows.h>

class  Student_list
{
private:

	struct Student
	{
		std::string name;
		int rate_math=0;
		int rate_phis=0;
		int rate_inform=0;
	};
	
	std::istringstream stream;// буфер для конвертации из стринг в инт
	std::string str; // захват строки из файла
	std::ifstream f_buff; // файловый поток
	std::vector<Student> vect;
public:
	

	Student_list(const char  file_name[])
	{
		f_buff.open(file_name);
	}


	void read() // функция обрабатывает файловый поток из вне
	{

		while (std::getline(f_buff, str))// извлечение и итерация одновременно
		{
			
			Student stud; // структура студента
			bool lock = true; // 

			for (int i = 0; i < str.length(); i++)
			{
				if (std::isdigit(str[i])) // проверка на цифры
				{
					if (stud.rate_math == 0)
					{
						stream.str(&str[i]); // запись в буфер для конвертации из смтринг в инт
						  stream >> stud.rate_math;  // конвертация 
						  stream.clear(); //
						  stream.str().resize(0);//  очистка буфера
						continue; // конец итерации что бы не записалось число в стринг имени
					}
					if (stud.rate_phis == 0)
					{
						stream.str(&str[i]);
						stream >> stud.rate_phis;
						stream.clear();
						stream.str().resize(0);
						continue;
					}
					if (stud.rate_inform == 0)
					{
						stream.str(&str[i]);
						stream >> stud.rate_inform;
						stream.clear();
						stream.str().resize(0);
						continue;
					}

				}
				if (std::isspace(str[i])&& std::isspace(str[i+1])) // защита от 2 пробелов подряд что бы не засорять имя
					continue;


						stud.name += str[i]; // запись всего что не прошло проверку в имя 
			}
			vect.push_back(stud); // запись структуры студента в вектор
		}
	}

	void print() //вывод на экран
	{
		std::sort(vect.begin(), vect.end()); // сортировка вектора по средниму арефметическому всех оценок
		for (int i = 0; i < vect.size(); i++)
		{
			std::cout << vect[i];
		}

	}

	friend bool operator < (const Student& left, const Student& right) // перегрузка сравнения
	{
		return left.rate_inform+ left.rate_math+ left.rate_phis > right.rate_inform + right.rate_math + right.rate_phis;
	}

	friend std::ostream& operator <<(std::ostream &out, Student &stud) // перегрузка вывода
	{
		out << std::setw(25) << std::left << stud.name <<
			" Math = "   << stud.rate_math  <<
			" Phis = "   << stud.rate_phis  <<
			" Inform = " << stud.rate_inform<<std::endl;
		return out;
	}

};


int main()
{
	setlocale(0, "");////////////////////////
	SetConsoleCP(1251);//  Русификация
	SetConsoleOutputCP(1251);/////////////////


	Student_list test ("Text.txt");// захват
	test.read();// чтение
	test.print();// вывод

	return 0;

	// код работает но есть небольшой баг если есть вариант как решить напишите 
	// stream.str(&str[i]) захватывает цифры по 1 если в файле все через пробелы  но если написать оценки без пробела 
	// 123  то он захватит сразу все и в выводе будет   123  23  3    вопрос как улучшить конвертацию
}

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

78

79

80

81

82

83

84

85

86

87

88

89

90

91

92

93

94

95

96

97

98

99

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

#include <iostream>

#include <string>

#include <fstream>

#include <cctype>

#include <vector>

#include <iomanip>

#include <sstream>

#include <algorithm>

#include <windows.h>

class Student_list

{

private:

struct Student

{

std::string name;

int rate_math=0;

int rate_phis=0;

int rate_inform=0;

};

std::istringstream stream;// буфер для конвертации из стринг в инт

std::string str; // захват строки из файла

std::ifstream f_buff; // файловый поток

std::vector<Student> vect;

public:

Student_list(const char file_name[])

{

f_buff.open(file_name);

}

void read() // функция обрабатывает файловый поток из вне

{

while (std::getline(f_buff, str))// извлечение и итерация одновременно

{

Student stud; // структура студента

bool lock = true; //

for (int i = 0; i < str.length(); i++)

{

if (std::isdigit(str[i])) // проверка на цифры

{

if (stud.rate_math == 0)

{

stream.str(&str[i]); // запись в буфер для конвертации из смтринг в инт

stream >> stud.rate_math; // конвертация

stream.clear(); //

stream.str().resize(0);// очистка буфера

continue; // конец итерации что бы не записалось число в стринг имени

}

if (stud.rate_phis == 0)

{

stream.str(&str[i]);

stream >> stud.rate_phis;

stream.clear();

stream.str().resize(0);

continue;

}

if (stud.rate_inform == 0)

{

stream.str(&str[i]);

stream >> stud.rate_inform;

stream.clear();

stream.str().resize(0);

continue;

}

if (std::isspace(str[i])&& std::isspace(str[i+1])) // защита от 2 пробелов подряд что бы не засорять имя

continue;

stud.name += str[i]; // запись всего что не прошло проверку в имя

}

vect.push_back(stud); // запись структуры студента в вектор

}

void print() //вывод на экран

{

std::sort(vect.begin(), vect.end()); // сортировка вектора по средниму арефметическому всех оценок

for (int i = 0; i < vect.size(); i++)

{

std::cout << vect[i];

}

friend bool operator < (const Student& left, const Student& right) // перегрузка сравнения

{

return left.rate_inform+ left.rate_math+ left.rate_phis > right.rate_inform + right.rate_math + right.rate_phis;

}

friend std::ostream& operator <<(std::ostream &out, Student &stud) // перегрузка вывода

{

out << std::setw(25) << std::left << stud.name <<

" Math = " << stud.rate_math <<

" Phis = " << stud.rate_phis <<

" Inform = " << stud.rate_inform<<std::endl;

return out;

}

};

int main()

{

setlocale(0, "");////////////////////////

SetConsoleCP(1251);// Русификация

SetConsoleOutputCP(1251);/////////////////

Student_list test ("Text.txt");// захват

test.read();// чтение

test.print();// вывод

return 0;

// код работает но есть небольшой баг если есть вариант как решить напишите

// stream.str(&str[i]) захватывает цифры по 1 если в файле все через пробелы но если написать оценки без пробела

// 123 то он захватит сразу все и в выводе будет 123 23 3 вопрос как улучшить конвертацию

}

Ответить

RockNRullz:

27 апреля 2020 в 18:46

Задание №3:

ВНИМАНИЕ: чтобы адекватно считывались русские символы, txt файл должен быть в кодировке ANSI

Список
*****************************************************************************
10 Абатуров Константин Иванович 2 1 4 Аверченко Аркадий Тимофеевич 1 3 5 Асов Александр Игоревич 3 3 3 Бень Евгений Моисеевич 2 1 5 Вагин Всеволод Иванович 2 3 4 Белокрылов Василий Алексеевич 1 2 3 Гершензон Михаил Осипович 4 5 2 Домашнев Сергей Герасимович 1 2 3 Волков Константин Сергеевич 3 2 1 Инбер Вера Михайловна 2 1 1
**********************************************************************

main.cpp:

#include <iostream>
#include <string>
#include <vector>
#include <fstream>
#include <algorithm> //для std::sort

class Student
{
public:
	std::string m_surname{ "" }, m_name{ "" }, m_midName{ "" };//фамилия, имя, отчество
	size_t m_math{ 0 }, m_phys{ 0 }, m_inf{ 0 }; //математика, физика, информатика
	double m_averageScore{ 0 }; //средний балл
	Student()
	{
	} 
};

void fillList()
{
	std::vector<Student> a;
	size_t len; //длина списка
	std::ifstream inf("input_data.txt");
	inf >> len; //считываем длину массива из первой строки
	a.resize(len);
	for (size_t iii(0); iii < a.size(); ++iii) //заполняем элементы массива
	{
		inf >> a[iii].m_surname >> a[iii].m_name >> a[iii].m_midName >> a[iii].m_math >> a[iii].m_phys >> a[iii].m_inf;
		a[iii].m_averageScore = (static_cast<double>(a[iii].m_math) + a[iii].m_phys + a[iii].m_inf) / 3; //средний балл
	}
	std::cout << '\n';
	std::sort(a.begin(), a.end(), [](Student const& lhs, Student const& rhs)->bool
		{return lhs.m_averageScore > rhs.m_averageScore; }); //сортируем с помощью лямбда-функции по среднему баллу
	for (size_t iii(0); iii < a.size(); ++iii) //выводим на экран
	{
		std::cout << "Студент №" << iii + 1 << '\n' << a[iii].m_surname << ' ' << a[iii].m_name <<
			' ' << a[iii].m_midName << '\n' << "Математика:\t" << a[iii].m_math << "\nФизика:\t\t" << a[iii].m_phys
			<< "\nИнформатика:\t" << a[iii].m_inf << "\nСредний балл:\t" << a[iii].m_averageScore << "\n\n";
	}
}

int main()
{
	setlocale(LC_ALL, "Rus");
	fillList();

	return 0;
}

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

#include <iostream>

#include <string>

#include <vector>

#include <fstream>

#include <algorithm> //для std::sort

class Student

{

public:

std::string m_surname{ "" }, m_name{ "" }, m_midName{ "" };//фамилия, имя, отчество

size_t m_math{ 0 }, m_phys{ 0 }, m_inf{ 0 }; //математика, физика, информатика

double m_averageScore{ 0 }; //средний балл

Student()

{

}

};

void fillList()

{

std::vector<Student> a;

size_t len; //длина списка

std::ifstream inf("input_data.txt");

inf >> len; //считываем длину массива из первой строки

a.resize(len);

for (size_t iii(0); iii < a.size(); ++iii) //заполняем элементы массива

{

inf >> a[iii].m_surname >> a[iii].m_name >> a[iii].m_midName >> a[iii].m_math >> a[iii].m_phys >> a[iii].m_inf;

a[iii].m_averageScore = (static_cast<double>(a[iii].m_math) + a[iii].m_phys + a[iii].m_inf) / 3; //средний балл

}

std::cout << '\n';

std::sort(a.begin(), a.end(), [](Student const& lhs, Student const& rhs)->bool

{return lhs.m_averageScore > rhs.m_averageScore; }); //сортируем с помощью лямбда-функции по среднему баллу

for (size_t iii(0); iii < a.size(); ++iii) //выводим на экран

{

std::cout << "Студент №" << iii + 1 << '\n' << a[iii].m_surname << ' ' << a[iii].m_name <<

' ' << a[iii].m_midName << '\n' << "Математика:\t" << a[iii].m_math << "\nФизика:\t\t" << a[iii].m_phys

<< "\nИнформатика:\t" << a[iii].m_inf << "\nСредний балл:\t" << a[iii].m_averageScore << "\n\n";

}

int main()

{

setlocale(LC_ALL, "Rus");

fillList();

return 0;

}

Ответить

Владимир:

19 января 2020 в 02:48

Задание №3

https://pastebin.com/R3PjrD5X

Ответить

Владимир:

19 января 2020 в 02:35

// Задание №2

#include <iostream>
#include <string>

int main()
{
	setlocale(0, ""); // вывод кириллицы
	system("color 4e"); // цвет консоли
	std::cout << "Программа проверяет, является ли введенная строка целым числом.\n\nВведите строку : ";
	std::string int_; // число пользователя
	getline(std::cin, int_);

	bool float_point_num = false; // символ '.' относящийся к вещественным числам
	bool not_num = false; // символ не относящийся к элементам числа
	bool negative = false; // знак '-' отрицательного числа
	int count_point{}; // счетчик символов '.'

	for (int i{}; i < int_.length(); ++i) {
		if (int_[i] >= '0' && int_[i] <= '9' || int_[i] == '-' || int_[i] == '.') { // допустимые символы числа
			if (int_[i] == '-') // если символ '-'
				if (i == 0) negative = true; // первый в строке, то число отрицательное
				else not_num = true; // иначе строка - не число
			if (int_[i] == '.') // если символ '.'
				if (int_[0] == '-' && int_[1] == '.')  not_num = true; // строка - не число
				else if (i != 0 && i != (int_.length() - 1) && count_point++ == 0) float_point_num = true; // число вещественное
				else not_num = true; // иначе строка - не число
		}
		else not_num = true; // строка - не число
	}
	if (not_num) std::cout << "строка \"" << int_ << "\" - не является числом\n";
	else if (negative && count_point) std::cout << "строка \"" << int_ << "\" - является отрицательным, вещественным числом\n";
	else if (negative) std::cout << "строка \"" << int_ << "\" - является отрицательным целым числом\n";
	else if (count_point) std::cout << "строка \"" << int_ << "\" - является вещественным числом\n";
	else std::cout << "строка \"" << int_ << "\" - является целым числом\n";
	return 0;
}

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

#include <iostream>

#include <string>

int main()

{

setlocale(0, ""); // вывод кириллицы

system("color 4e"); // цвет консоли

std::cout << "Программа проверяет, является ли введенная строка целым числом.\n\nВведите строку : ";

std::string int_; // число пользователя

getline(std::cin, int_);

bool float_point_num = false; // символ '.' относящийся к вещественным числам

bool not_num = false; // символ не относящийся к элементам числа

bool negative = false; // знак '-' отрицательного числа

int count_point{}; // счетчик символов '.'

for (int i{}; i < int_.length(); ++i) {

if (int_[i] >= '0' && int_[i] <= '9' || int_[i] == '-' || int_[i] == '.') { // допустимые символы числа

if (int_[i] == '-') // если символ '-'

if (i == 0) negative = true; // первый в строке, то число отрицательное

else not_num = true; // иначе строка - не число

if (int_[i] == '.') // если символ '.'

if (int_[0] == '-' && int_[1] == '.') not_num = true; // строка - не число

else if (i != 0 && i != (int_.length() - 1) && count_point++ == 0) float_point_num = true; // число вещественное

else not_num = true; // иначе строка - не число

}

else not_num = true; // строка - не число

}

if (not_num) std::cout << "строка \"" << int_ << "\" - не является числом\n";

else if (negative && count_point) std::cout << "строка \"" << int_ << "\" - является отрицательным, вещественным числом\n";

else if (negative) std::cout << "строка \"" << int_ << "\" - является отрицательным целым числом\n";

else if (count_point) std::cout << "строка \"" << int_ << "\" - является вещественным числом\n";

else std::cout << "строка \"" << int_ << "\" - является целым числом\n";

return 0;

}

Ответить

Анастасия:

19 декабря 2019 в 05:51

На третьем задании я тоже очень надолго застряла, так как хотела сделать класс-контейнер полегче, то есть чтобы он содержал указатели, а не сами структуры студентов. Я хотела использовать умные указатели, но не могла нормально запустить программу, компилятор на что-то длинно и непонятно ругался, отладка тоже не помогала. В итоге я плюнула на умные указатели и сделала с обычными. А потом до меня дошло, что не так было с умными.

НО программа работает только с данными в файле на латинице, если там кириллица, возникает run-time error на этапе проверки строк файла на корректность формата (видит непонятные символы вместо букв). Как с этим бороться, я не знаю.
Итак, с гордостью представляю моё решение задания №3 (итого три файла, три куска кода):

Файл Student_data.h:

#ifndef STUDENT_DATA
#define STUDENT_DATA

#include <iostream>
#include <string>  // для работы со строками

using std::cout; using std::string;

// структура полное имя - ФИО
struct Full_name
{
	string surname_;
	string name_;
	string patronymic_;
	// Full_name() {}
	Full_name(string surname, string name, string patronymic) :
		surname_(surname), name_(name), patronymic_(patronymic)
	{}
};

// класс данных о студенте - ФИО, оценки и средний балл
class Student_data
{
public:
	// перечисление возможных оценок
	enum marks { one = 1, bad, satisfactorily, good, excellent };

	// чтобы не создавать геттеры, делаю все данные публичными:
	Full_name full_name_;
	marks math_;
	marks physics_;
	marks info_technology_;
	double average_score_;

	// конструктор класса
	Student_data(const string& surname, const string& name, const string& patronymic, const marks first_mark, const marks second_mark, const marks third_mark) :
		full_name_(Full_name(surname, name, patronymic)), math_(first_mark), physics_(second_mark), info_technology_(third_mark),
		average_score_(static_cast<double>(first_mark + second_mark + third_mark) / 3)
	{}

	// перегрузка оператора вывода данных студента
	friend std::ostream& operator<<(std::ostream& out, const Student_data& student)
	{
		out << student.full_name_.surname_ << " " << student.full_name_.name_ << " " << student.full_name_.patronymic_
			<< " " << student.math_ << " " << student.physics_ << " " << student.info_technology_ << '\n';
		return out;
	}
};

#endif

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

#ifndef STUDENT_DATA

#define STUDENT_DATA

#include <iostream>

#include <string> // для работы со строками

using std::cout; using std::string;

// структура полное имя - ФИО

struct Full_name

{

string surname_;

string name_;

string patronymic_;

// Full_name() {}

Full_name(string surname, string name, string patronymic) :

surname_(surname), name_(name), patronymic_(patronymic)

{}

};

// класс данных о студенте - ФИО, оценки и средний балл

class Student_data

{

public:

// перечисление возможных оценок

enum marks { one = 1, bad, satisfactorily, good, excellent };

// чтобы не создавать геттеры, делаю все данные публичными:

Full_name full_name_;

marks math_;

marks physics_;

marks info_technology_;

double average_score_;

// конструктор класса

Student_data(const string& surname, const string& name, const string& patronymic, const marks first_mark, const marks second_mark, const marks third_mark) :

full_name_(Full_name(surname, name, patronymic)), math_(first_mark), physics_(second_mark), info_technology_(third_mark),

average_score_(static_cast<double>(first_mark + second_mark + third_mark) / 3)

{}

// перегрузка оператора вывода данных студента

friend std::ostream& operator<<(std::ostream& out, const Student_data& student)

{

out << student.full_name_.surname_ << " " << student.full_name_.name_ << " " << student.full_name_.patronymic_

<< " " << student.math_ << " " << student.physics_ << " " << student.info_technology_ << '\n';

return out;

}

};

#endif

Файл The_list_of_students.h:

#ifndef THE_LIST_OF_STUDENTS
#define THE_LIST_OF_STUDENTS

#include <vector>  // для std::vector
#include <memory>  // для работы с умными указателями
#include <utility> // для передачи умного указателя как r-value
#include <algorithm> // для использования алгоритмов сортировки
#include "Student_data.h"

using std::vector;

// класс-контейнер для обработки данных о студентах
class The_list_of_students
{
private:
	vector<std::unique_ptr<Student_data>> students; // вектор из умных указателей на класс
	unsigned number_of_students;
public:
	// конструктор класса
	The_list_of_students() : students{}, number_of_students()
	{}

	// метод для задания количества студентов
	void set_number(const int some_number)
	{
		if (some_number < 0) cout << "Не удалось задать количество студентов" << '\n';
		else number_of_students = some_number;
	}

	// добавление данных о ещё одном студенте через умный указатель
	void add_student(std::unique_ptr<Student_data> student)
	{
		students.push_back(std::move(student));
		if (number_of_students < students.size())
			number_of_students = students.size();
	}

	// сортировка элементов вектора по среднему баллу от большего к меньшему
	void sort_by_average()
	{
		// Перебираем каждый элемент массива (кроме последнего, он уже будет отсортирован к тому времени, когда мы до него доберёмся)
		for (unsigned startIndex = 0; startIndex < (number_of_students - 1); ++startIndex)
		{
			// В переменной maximumIndex хранится индекс наибольшего значения, которое мы нашли в этой итерации
			// Начинаем с того, что наибольший элемент в этой итерации - это первый элемент (индекс 0)
			int maximumIndex = startIndex;

			// Затем ищем элемент поменьше в остальной части массива
			for (unsigned currentIndex = startIndex + 1; currentIndex < number_of_students; ++currentIndex)
			{
				if (students.at(currentIndex)->average_score_ > students.at(maximumIndex)->average_score_)
					maximumIndex = currentIndex;
			} // maximumIndex теперь индекс студента с наибольшим средним баллом 

			// Меняем местами наше начальное наибольшее число с тем, которое мы обнаружили
			std::swap(students[startIndex], students[maximumIndex]);
		}
	}

	// печать всех элементов массива
	void print()
	{
		cout << '\n';
		if (students.size() == 0) cout << "Список студентов пуст!" << '\n';
		else for (unsigned i = 0; i < students.size(); i++)
			cout << *students[i];
	}
};

#endif

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

#ifndef THE_LIST_OF_STUDENTS

#define THE_LIST_OF_STUDENTS

#include <vector> // для std::vector

#include <memory> // для работы с умными указателями

#include <utility> // для передачи умного указателя как r-value

#include <algorithm> // для использования алгоритмов сортировки

#include "Student_data.h"

using std::vector;

// класс-контейнер для обработки данных о студентах

class The_list_of_students

{

private:

vector<std::unique_ptr<Student_data>> students; // вектор из умных указателей на класс

unsigned number_of_students;

public:

// конструктор класса

The_list_of_students() : students{}, number_of_students()

{}

// метод для задания количества студентов

void set_number(const int some_number)

{

if (some_number < 0) cout << "Не удалось задать количество студентов" << '\n';

else number_of_students = some_number;

}

// добавление данных о ещё одном студенте через умный указатель

void add_student(std::unique_ptr<Student_data> student)

{

students.push_back(std::move(student));

if (number_of_students < students.size())

number_of_students = students.size();

}

// сортировка элементов вектора по среднему баллу от большего к меньшему

void sort_by_average()

{

// Перебираем каждый элемент массива (кроме последнего, он уже будет отсортирован к тому времени, когда мы до него доберёмся)

for (unsigned startIndex = 0; startIndex < (number_of_students - 1); ++startIndex)

{

// В переменной maximumIndex хранится индекс наибольшего значения, которое мы нашли в этой итерации

// Начинаем с того, что наибольший элемент в этой итерации - это первый элемент (индекс 0)

int maximumIndex = startIndex;

// Затем ищем элемент поменьше в остальной части массива

for (unsigned currentIndex = startIndex + 1; currentIndex < number_of_students; ++currentIndex)

{

if (students.at(currentIndex)->average_score_ > students.at(maximumIndex)->average_score_)

maximumIndex = currentIndex;

} // maximumIndex теперь индекс студента с наибольшим средним баллом

// Меняем местами наше начальное наибольшее число с тем, которое мы обнаружили

std::swap(students[startIndex], students[maximumIndex]);

}

// печать всех элементов массива

void print()

{

cout << '\n';

if (students.size() == 0) cout << "Список студентов пуст!" << '\n';

else for (unsigned i = 0; i < students.size(); i++)

cout << *students[i];

}

};

#endif

Файл main.cpp:

#include "The_list_of_students.h"
#include <fstream> // для работы с файлами
#include <cstdlib> // для exit
#include <sstream> // для работы со строковым потоком, чтобы превращать данные из строки в нужные данные разного типа

// ОБЪЯВЛЕНИЕ вспомогательных функций для чтения из файла:
bool line_is_ok(const string&);
std::unique_ptr<Student_data> convert_string_to_smart_pointer(const string&);
unsigned short get_number_of_students_from_file(const string&);

// заполняем передаваемый массив данных о студентах данными из файла
void fill_from_file(The_list_of_students& array)
{
	std::ifstream data_file("input_data.txt");
	if (!data_file)
	{
		std::cerr << "Файл невозможно прочитать!" << '\n';
		exit(1);
	}

	// считываем количество строк в файле
	string number_from_file;
	getline(data_file, number_from_file);
	unsigned short n_students = get_number_of_students_from_file(number_from_file);
	array.set_number(n_students);

	unsigned short lines_index = 0;
	while (lines_index < n_students)  // читаем только обозначенное в файле количество строк, остальные не читаем
	{
		string line_from_file;
		getline(data_file, line_from_file);
		if (line_is_ok(line_from_file))
		{
			auto student_ptr = convert_string_to_smart_pointer(line_from_file);
			array.add_student(std::move(student_ptr));
		}
		else cout << "В файле есть некорректная строка" << '\n';
		++lines_index;
	}
}

int main()
{
	setlocale(LC_CTYPE, "rus");   // для вывода сообщений на кириллице

	The_list_of_students Students{};
	fill_from_file(Students);
	Students.sort_by_average();
	cout << "ФИО студентов с оценками в порядке убывания их среднего балла:";
	Students.print();

	return 0;
}

// РЕАЛИЗАЦИЯ вспомогательных функций для чтения из файла:

// функция возвращает истину, если строка соответствует ожидаемому формату "Ф И О ц1 ц1 ц3" и ложь, если не соответствует
bool line_is_ok(const string& line_from_file)
{
	if (line_from_file.length() < 10) return false; //т.к. строка должна иметь вид "Ф И О ц1 ц1 ц3" - как минимум 11 символов
	unsigned short spaces_counter = 0; // счётчик пробелов
	unsigned short index = 0;          // индекс символов строки

	while ((index < line_from_file.size()) && (spaces_counter < 6))
		// 1ый пробел - окончание фамилии, 2ой- окончание имени, 3ий - отчества, потом через пробел идут три оценки
	{
		if (isspace(line_from_file[index]))
			spaces_counter++;
		else
		{
			if ((spaces_counter < 3) && (!isalpha(line_from_file[index]))) return false;
			if ((spaces_counter >= 3) && (!isdigit(line_from_file[index]))) return false;
		}
		index++;
	}
	if (index < line_from_file.size()) return false; // если было 6 и более пробелов до конца строки
	else return true;
}

// функция превращает строку в правильном формате в умный указатель на класс с данными о студенте
std::unique_ptr<Student_data> convert_string_to_smart_pointer(const string& correct_string)
{
	std::stringstream string_from_file;
	string_from_file << correct_string;

	string surname, name, patronymic;
	string_from_file >> surname;
	string_from_file >> name;
	string_from_file >> patronymic;

	unsigned short math(0), physics(0), it(0);
	string_from_file >> math;
	string_from_file >> physics;
	string_from_file >> it;

	return std::make_unique<Student_data>(surname, name, patronymic, static_cast<Student_data::marks>(math), static_cast<Student_data::marks>(physics), static_cast<Student_data::marks>(it));
}

// считываем количество строк в файле
unsigned short get_number_of_students_from_file(const string& number_from_file)
{
	std::stringstream number;
	number << number_from_file;
	unsigned short n(0);
	number >> n;
	return n;
}

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

78

79

80

81

82

83

84

85

86

87

88

89

90

91

92

93

94

95

96

97

98

99

100

101

102

103

104

105

106

107

#include "The_list_of_students.h"

#include <fstream> // для работы с файлами

#include <cstdlib> // для exit

#include <sstream> // для работы со строковым потоком, чтобы превращать данные из строки в нужные данные разного типа

// ОБЪЯВЛЕНИЕ вспомогательных функций для чтения из файла:

bool line_is_ok(const string&);

std::unique_ptr<Student_data> convert_string_to_smart_pointer(const string&);

unsigned short get_number_of_students_from_file(const string&);

// заполняем передаваемый массив данных о студентах данными из файла

void fill_from_file(The_list_of_students& array)

{

std::ifstream data_file("input_data.txt");

if (!data_file)

{

std::cerr << "Файл невозможно прочитать!" << '\n';

exit(1);

}

// считываем количество строк в файле

string number_from_file;

getline(data_file, number_from_file);

unsigned short n_students = get_number_of_students_from_file(number_from_file);

array.set_number(n_students);

unsigned short lines_index = 0;

while (lines_index < n_students) // читаем только обозначенное в файле количество строк, остальные не читаем

{

string line_from_file;

getline(data_file, line_from_file);

if (line_is_ok(line_from_file))

{

auto student_ptr = convert_string_to_smart_pointer(line_from_file);

array.add_student(std::move(student_ptr));

}

else cout << "В файле есть некорректная строка" << '\n';

++lines_index;

}

int main()

{

setlocale(LC_CTYPE, "rus"); // для вывода сообщений на кириллице

The_list_of_students Students{};

fill_from_file(Students);

Students.sort_by_average();

cout << "ФИО студентов с оценками в порядке убывания их среднего балла:";

Students.print();

return 0;

}

// РЕАЛИЗАЦИЯ вспомогательных функций для чтения из файла:

// функция возвращает истину, если строка соответствует ожидаемому формату "Ф И О ц1 ц1 ц3" и ложь, если не соответствует

bool line_is_ok(const string& line_from_file)

{

if (line_from_file.length() < 10) return false; //т.к. строка должна иметь вид "Ф И О ц1 ц1 ц3" - как минимум 11 символов

unsigned short spaces_counter = 0; // счётчик пробелов

unsigned short index = 0; // индекс символов строки

while ((index < line_from_file.size()) && (spaces_counter < 6))

// 1ый пробел - окончание фамилии, 2ой- окончание имени, 3ий - отчества, потом через пробел идут три оценки

{

if (isspace(line_from_file[index]))

spaces_counter++;

else

{

if ((spaces_counter < 3) && (!isalpha(line_from_file[index]))) return false;

if ((spaces_counter >= 3) && (!isdigit(line_from_file[index]))) return false;

}

index++;

}

if (index < line_from_file.size()) return false; // если было 6 и более пробелов до конца строки

else return true;

}

// функция превращает строку в правильном формате в умный указатель на класс с данными о студенте

std::unique_ptr<Student_data> convert_string_to_smart_pointer(const string& correct_string)

{

std::stringstream string_from_file;

string_from_file << correct_string;

string surname, name, patronymic;

string_from_file >> surname;

string_from_file >> name;

string_from_file >> patronymic;

unsigned short math(0), physics(0), it(0);

string_from_file >> math;

string_from_file >> physics;

string_from_file >> it;

return std::make_unique<Student_data>(surname, name, patronymic, static_cast<Student_data::marks>(math), static_cast<Student_data::marks>(physics), static_cast<Student_data::marks>(it));

}

// считываем количество строк в файле

unsigned short get_number_of_students_from_file(const string& number_from_file)

{

std::stringstream number;

number << number_from_file;

unsigned short n(0);

number >> n;

return n;

}

Ответить

Владимир:

19 января 2020 в 16:17

Анастасия, для работы программы с кириллицей, нужно стейтмент (файл main.cpp, стр.71):

if ((spaces_counter < 3) && (!isalpha(line_from_file[index]))) return false;

1

if ((spaces_counter < 3) && (!isalpha(line_from_file[index]))) return false;

заменить на:

if ((spaces_counter < 3) && (!isalpha((unsigned char)line_from_file[index]))) return false;

1

if ((spaces_counter < 3) && (!isalpha((unsigned char)line_from_file[index]))) return false;

Ответить

Анастасия:

18 декабря 2019 в 10:29

Моё решение задания №2:

#include <iostream>
#include <clocale>  // для вывода на кириллице

using std::cout; using std::cin; using std::endl;

// самописная функция вычисления модуля числа
double absolute(double number)
{
	if (number >= 0) return number;
	else return -number;
}

// получаем от пользователя количество чисел в последовательности
void check()
{
	cout << "Введите строку: ";
	double answer;
	cin >> answer;
	if (cin.fail()|| (absolute(answer - static_cast<int>(answer)) > 0))
	{
		cin.clear();
		cin.ignore(1000, '\n');
		cout << "Введённая строка - не целое число." << endl;
	}
	else cout << "Вы ввели целое число." << endl;
}

int main()
{
	setlocale(LC_CTYPE, "rus"); // для вывода на кириллице
	while (true) check();
	return 0;
}

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

#include <iostream>

#include <clocale> // для вывода на кириллице

using std::cout; using std::cin; using std::endl;

// самописная функция вычисления модуля числа

double absolute(double number)

{

if (number >= 0) return number;

else return -number;

}

// получаем от пользователя количество чисел в последовательности

void check()

{

cout << "Введите строку: ";

double answer;

cin >> answer;

if (cin.fail()|| (absolute(answer - static_cast<int>(answer)) > 0))

{

cin.clear();

cin.ignore(1000, '\n');

cout << "Введённая строка - не целое число." << endl;

}

else cout << "Вы ввели целое число." << endl;

}

int main()

{

setlocale(LC_CTYPE, "rus"); // для вывода на кириллице

while (true) check();

return 0;

}

Ответить

Анастасия:

15 января 2020 в 20:37

Комментарий в 13 строчке — левый =(

Ответить

Анастасия:

18 декабря 2019 в 10:16

Седьмая часть практикума застала меня врасплох, первое "Easy" задание я не могла решить больше недели, так как мы такого не проходили, а советы из интернета сначала и вовсе не работали, а потом работали не так, как надо. И так, вот моё вымученное решение задания №1, пока без учёта прерывания по нажатию любой клавиши.

#define _CRT_SECURE_NO_WARNINGS  // без этого не работают основный функции

#include <iostream>
#include <ctime>     // для функций с временем и датой системы
#include <chrono>    // для std::chrono (для таймера)
#include <Windows.h> // для функции задержки выполнения программы
#include <stdlib.h>  // для очистки окна консоли

// класс с функцией счётчика времени из 129 урока
class Timer
{
private:
	using clock_t = std::chrono::high_resolution_clock;
	using second_t = std::chrono::duration<double, std::ratio<1>>;
	std::chrono::time_point<clock_t> m_beg;  // начало временного интервала
public:
	Timer() : m_beg(clock_t::now())   // при создании объекта класса начало временного интервала определяем как "сейчас"
	{
	}
	void reset() // метод "перезагрузки", когда опять засекаем время
	{
		m_beg = clock_t::now();
	}
	double elapsed() const // метод считает пройденное время от начала временного интервала
	{
		return std::chrono::duration_cast<second_t>(clock_t::now() - m_beg).count();
	}
};

// функция очистки окна консоли
void clear_console()
{
	#if defined(_WIN32)
		system("CLS");
	#else
		system("clear");
	#endif
}

// функция задержки работы программы
void wait(const unsigned int milliseconds)
{
#if defined(_WIN32)
	Sleep(milliseconds);
#else
	{
		#include <unistd.h> 
		usleep(milliseconds);
	}
#endif
}

namespace Time_constants
{
	const unsigned short seconds_in_one_minute = 60;
	const unsigned short minutes_for_work = 3;
}

void print_time(const std::tm* time)
{
	// выводим время в привычном формате ЧЧ:ММ:СС, иначе может быть 9:7:1
	if (time->tm_hour < 10)
		std::cout << "0" << time->tm_hour << ":";
	else std::cout << time->tm_hour << ":";
	if (time->tm_min < 10)
		std::cout << "0" << time->tm_min << ":";
	else std::cout << time->tm_min << ":";
	if (time->tm_sec < 10)
		std::cout << "0" << time->tm_sec << std::endl;
	else std::cout << time->tm_sec << std::endl;

	//так тоже можно, но формат немного избыточный, время, обработанное функцией asctime
	//std::cout << asctime(time) << std::endl;
}

int main()
{
	setlocale(LC_CTYPE, "rus"); // для вывода на кириллице
	std::cout << "Программа будет показывать на экране время в течение трёх минут ИЛИ пока Вы не нажмёте любую клавишу." << std::endl << std::endl;
	wait(3000); // даём возможность пользователю прочитать это сообщение

	std::time_t current_time = std::time(0);   //  = std::time(NULL); как вариант, функция возвращает время в секундах начиная с 1 января 1970 г
	std::tm* local_time = std::localtime(&current_time); // преобразует календарное время, сохраняет его в структуре tm и возвращает указатель на неё 

	Timer t; // засекаем время, создавая объект класса Timer

	do
	{ 
		clear_console(); 
		
		// пересматриваем время:
		current_time = std::time(0);
		local_time = std::localtime(&current_time);

		print_time(local_time);  // форматируем время вручную

		wait(333); // чтобы программа не прокручивала всё это по 100500 раз в секунду, а максимум три

	} while (t.elapsed() < (Time_constants::minutes_for_work * Time_constants::seconds_in_one_minute));
	// пока не истечёт время по таймеру

	return 0;
}

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

78

79

80

81

82

83

84

85

86

87

88

89

90

91

92

93

94

95

96

97

98

99

100

101

102

103

#define _CRT_SECURE_NO_WARNINGS // без этого не работают основный функции

#include <iostream>

#include <ctime> // для функций с временем и датой системы

#include <chrono> // для std::chrono (для таймера)

#include <Windows.h> // для функции задержки выполнения программы

#include <stdlib.h> // для очистки окна консоли

// класс с функцией счётчика времени из 129 урока

class Timer

{

private:

using clock_t = std::chrono::high_resolution_clock;

using second_t = std::chrono::duration<double, std::ratio<1>>;

std::chrono::time_point<clock_t> m_beg; // начало временного интервала

public:

Timer() : m_beg(clock_t::now()) // при создании объекта класса начало временного интервала определяем как "сейчас"

{

}

void reset() // метод "перезагрузки", когда опять засекаем время

{

m_beg = clock_t::now();

}

double elapsed() const // метод считает пройденное время от начала временного интервала

{

return std::chrono::duration_cast<second_t>(clock_t::now() - m_beg).count();

}

};

// функция очистки окна консоли

void clear_console()

{

#if defined(_WIN32)

system("CLS");

#else

system("clear");

#endif

}

// функция задержки работы программы

void wait(const unsigned int milliseconds)

{

#if defined(_WIN32)

Sleep(milliseconds);

#else

{

#include <unistd.h>

usleep(milliseconds);

}

#endif

}

namespace Time_constants

{

const unsigned short seconds_in_one_minute = 60;

const unsigned short minutes_for_work = 3;

}

void print_time(const std::tm* time)

{

// выводим время в привычном формате ЧЧ:ММ:СС, иначе может быть 9:7:1

if (time->tm_hour < 10)

std::cout << "0" << time->tm_hour << ":";

else std::cout << time->tm_hour << ":";

if (time->tm_min < 10)

std::cout << "0" << time->tm_min << ":";

else std::cout << time->tm_min << ":";

if (time->tm_sec < 10)

std::cout << "0" << time->tm_sec << std::endl;

else std::cout << time->tm_sec << std::endl;

//так тоже можно, но формат немного избыточный, время, обработанное функцией asctime

//std::cout << asctime(time) << std::endl;

}

int main()

{

setlocale(LC_CTYPE, "rus"); // для вывода на кириллице

std::cout << "Программа будет показывать на экране время в течение трёх минут ИЛИ пока Вы не нажмёте любую клавишу." << std::endl << std::endl;

wait(3000); // даём возможность пользователю прочитать это сообщение

std::time_t current_time = std::time(0); // = std::time(NULL); как вариант, функция возвращает время в секундах начиная с 1 января 1970 г

std::tm* local_time = std::localtime(&current_time); // преобразует календарное время, сохраняет его в структуре tm и возвращает указатель на неё

Timer t; // засекаем время, создавая объект класса Timer

do

{

clear_console();

// пересматриваем время:

current_time = std::time(0);

local_time = std::localtime(&current_time);

print_time(local_time); // форматируем время вручную

wait(333); // чтобы программа не прокручивала всё это по 100500 раз в секунду, а максимум три

} while (t.elapsed() < (Time_constants::minutes_for_work * Time_constants::seconds_in_one_minute));

// пока не истечёт время по таймеру

return 0;

}

P.S. многочисленные комментарии, поясняющие работу всех новых для меня вещей, я убрала, чтобы никого не пугать длинющим кодом.

Ответить

Алена:

10 декабря 2019 в 14:54

Задача 2.

#include <iostream>
#include <string>
#include <sstream>

//Функция возвращает true, если строка - целое число
bool isInteger(const std::string& someString)
{
	std::stringstream bufferString (someString);
	int nValue;
	//если извлечение успешно И поток достиг конца
	if ((bufferString >> nValue) && (bufferString.eof())) 
		return true;
	else
		return false;

}

int main()
{
	setlocale(LC_ALL, "Rus");
	std::cout << "***Программа проверяет, является ли введенная пользователем строка целым числом***\n\n"
		<<"Введите строку : ";
	std::string userString;
	std::getline(std::cin, userString);
	if (isInteger(userString))
		std::cout << userString << " - это целое число.\n\n";
	else
		std::cout << userString << " не является целым числом.\n\n";
}

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

#include <iostream>

#include <string>

#include <sstream>

//Функция возвращает true, если строка - целое число

bool isInteger(const std::string& someString)

{

std::stringstream bufferString (someString);

int nValue;

//если извлечение успешно И поток достиг конца

if ((bufferString >> nValue) && (bufferString.eof()))

return true;

else

return false;

}

int main()

{

setlocale(LC_ALL, "Rus");

std::cout << "***Программа проверяет, является ли введенная пользователем строка целым числом***\n\n"

<<"Введите строку : ";

std::string userString;

std::getline(std::cin, userString);

if (isInteger(userString))

std::cout << userString << " - это целое число.\n\n";

else

std::cout << userString << " не является целым числом.\n\n";

}

Ответить

Алена:

6 декабря 2019 в 12:46

Задача 1.

#include <iostream>
#include <windows.h> //для структуры SYSTEMTIME и функции GetLocalTime()
#include <conio.h> //для _kbhit (ожидание нажатия клавиши)

int main()
{
	setlocale(LC_ALL, "Rus");
	std::cout << "\t***Часы работают 3 минуты***\n"
		<< "***Вы можете остановить их нажатием любой клавиши***\n\n";

	//Структура(!) SYSTEMTIME представляет дату и время,
	//используя отдельные члены для месяца, дня, года, дня недели, часа, минут, секунд и миллисекунд
	SYSTEMTIME locTime;
	// Функция GetLocalTime извлекает текущую локальную дату и время, у ф-ции нет возвращаемых значений
	// (GetSystemTime - дату и время текущей операционной системы, выражено в UTC)
	// Ссылка на структуру SYSTEMTIME, которая получит дату и время
	GetLocalTime(&locTime);
	// Выводим локальное время
	std::cout << "Старт:  " << locTime.wHour << ":"
		<< locTime.wMinute << ":" << locTime.wSecond << "\n";
	//Функция GetSystemTime извлекает дату и время текущей операционной системы, выражено в Универсальном глобальном время (UTC).

	//условие для остановки часов
	int stopMinute = locTime.wMinute + 3;
	int stopSecond = locTime.wSecond; 

	//Функция kbhit() возвращает истину, если нажата какая-либо клавиша на клавиатуре. 
	//В противном случае возвращается 0. В любом случае код клавиши не удаляется из входного буфера.
	while (!_kbhit()) //ожидание нажатия клавиши
	{
		GetLocalTime(&locTime);
		std::cout << "Время:  " << locTime.wHour << ":"
			<< locTime.wMinute << ":" << locTime.wSecond;
		std::cout << " \r"; //Возврат каретки - Перемещает позицию печати в крайнее левое положение
		if ((locTime.wMinute == stopMinute) && (locTime.wSecond == stopSecond)) // если прошло 3 минуты и дошли до тех же секунд
			break;
	}
	std::cout << "\nСтоп!\n\n";
}

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

#include <iostream>

#include <windows.h> //для структуры SYSTEMTIME и функции GetLocalTime()

#include <conio.h> //для _kbhit (ожидание нажатия клавиши)

int main()

{

setlocale(LC_ALL, "Rus");

std::cout << "\t***Часы работают 3 минуты***\n"

<< "***Вы можете остановить их нажатием любой клавиши***\n\n";

//Структура(!) SYSTEMTIME представляет дату и время,

//используя отдельные члены для месяца, дня, года, дня недели, часа, минут, секунд и миллисекунд

SYSTEMTIME locTime;

// Функция GetLocalTime извлекает текущую локальную дату и время, у ф-ции нет возвращаемых значений

// (GetSystemTime - дату и время текущей операционной системы, выражено в UTC)

// Ссылка на структуру SYSTEMTIME, которая получит дату и время

GetLocalTime(&locTime);

// Выводим локальное время

std::cout << "Старт: " << locTime.wHour << ":"

<< locTime.wMinute << ":" << locTime.wSecond << "\n";

//Функция GetSystemTime извлекает дату и время текущей операционной системы, выражено в Универсальном глобальном время (UTC).

//условие для остановки часов

int stopMinute = locTime.wMinute + 3;

int stopSecond = locTime.wSecond;

//Функция kbhit() возвращает истину, если нажата какая-либо клавиша на клавиатуре.

//В противном случае возвращается 0. В любом случае код клавиши не удаляется из входного буфера.

while (!_kbhit()) //ожидание нажатия клавиши

{

GetLocalTime(&locTime);

std::cout << "Время: " << locTime.wHour << ":"

<< locTime.wMinute << ":" << locTime.wSecond;

std::cout << " \r"; //Возврат каретки - Перемещает позицию печати в крайнее левое положение

if ((locTime.wMinute == stopMinute) && (locTime.wSecond == stopSecond)) // если прошло 3 минуты и дошли до тех же секунд

break;

}

std::cout << "\nСтоп!\n\n";

}

Ответить

Анастасия:

15 января 2020 в 20:16

Алёна, Вы хорошо поработали. Очень короткий код и работает, как надо. Я, правда, не проверила, что если, например 59 минут, как он три минуты прибавит, нормально? И формат часов немного непривычный, если меньше 10, то 0 не добавляется. Но за такую короткую рабочую программку эти мелочи простительны.

Ответить

Владимир:

16 октября 2019 в 14:06

Задание №1

#include <iostream>
#include "windows.h" // SYSTEMTIME, Sleep(), GetLocalTime()
#include <conio.h> // _kbhit()
SYSTEMTIME Time;

int main()
{
	system("color 1e"); // цвет консоли
	setlocale(0, ""); // вывод кириллицы
	std::cout << "Чтобы остановить часы, нажмите любую клавишу,\n" <<
		"иначе продолжительность работы часов - три минуты.\n\n";
	Sleep(700); // задержка между сообщением и выводом часов
	GetLocalTime(&Time); // функция возвращает локальное время
	std::cout << "Стартовое время:\t" << Time.wHour << ":" << Time.wMinute << ":" << Time.wSecond << "\n"; // выводим точку отсчета локального времени
	int flagSec = Time.wSecond; // флаг изменения минут и секунд
	int countMin(0), countSec(0); // счетчики минут и секунд

	while (true)
	{
		GetLocalTime(&Time); // функция возвращает локальное время
		std::cout << "Текущее время:\t\t" << Time.wHour << ":" << Time.wMinute << ":" << Time.wSecond; // показываем ход локального времени
		if (Time.wSecond != flagSec) { ++flagSec; ++countSec; } // если лок. время изменилось - меняем время таймера
		if (flagSec == 60) flagSec = 0; // если флаг достиг 60 сек. - сбрасываем до 0
		if (countSec == 60) { countSec = 0; ++countMin; } // если счетчик "Sec" достиг 60 сек. - сбрасываем до 0 и добавляем в "Min"
		std::cout << "  \tтаймер:\t" << countMin << ":" << countSec << " \r"; // показываем ход таймера, с точкой отсчета - 0
		if (_kbhit() || countMin == 3) { std::cout << "\n"; return 0; } // если нажать люб. клавишу, функция _kbhit() остановит исполнение прог.
		Sleep(30); // задержка меж итерациями
	}
	return 0;
}

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

#include <iostream>

#include "windows.h" // SYSTEMTIME, Sleep(), GetLocalTime()

#include <conio.h> // _kbhit()

SYSTEMTIME Time;

int main()

{

system("color 1e"); // цвет консоли

setlocale(0, ""); // вывод кириллицы

std::cout << "Чтобы остановить часы, нажмите любую клавишу,\n" <<

"иначе продолжительность работы часов - три минуты.\n\n";

Sleep(700); // задержка между сообщением и выводом часов

GetLocalTime(&Time); // функция возвращает локальное время

std::cout << "Стартовое время:\t" << Time.wHour << ":" << Time.wMinute << ":" << Time.wSecond << "\n"; // выводим точку отсчета локального времени

int flagSec = Time.wSecond; // флаг изменения минут и секунд

int countMin(0), countSec(0); // счетчики минут и секунд

while (true)

{

GetLocalTime(&Time); // функция возвращает локальное время

std::cout << "Текущее время:\t\t" << Time.wHour << ":" << Time.wMinute << ":" << Time.wSecond; // показываем ход локального времени

if (Time.wSecond != flagSec) { ++flagSec; ++countSec; } // если лок. время изменилось - меняем время таймера

if (flagSec == 60) flagSec = 0; // если флаг достиг 60 сек. - сбрасываем до 0

if (countSec == 60) { countSec = 0; ++countMin; } // если счетчик "Sec" достиг 60 сек. - сбрасываем до 0 и добавляем в "Min"

std::cout << " \tтаймер:\t" << countMin << ":" << countSec << " \r"; // показываем ход таймера, с точкой отсчета - 0

if (_kbhit() || countMin == 3) { std::cout << "\n"; return 0; } // если нажать люб. клавишу, функция _kbhit() остановит исполнение прог.

Sleep(30); // задержка меж итерациями

}

return 0;

}

Ответить

Анастасия:

15 января 2020 в 20:23

Владимир, очень интересно получилось. И коротко. У Алёны (выше) решение на Ваше похоже, но Вы ещё после 60 сбрасываете. Поэтому лучше у Вас спрошу: как Вы пришли к этому решению, что читали? Для меня эта задача была очень сложной, поэтому и спрашиваю.

Ответить
1. Владимир:
  
  18 января 2020 в 03:07
  
  Анастасия, я уже не помню, что конкретно читал, но это не литература, у меня методы наверное не отличаются от остальных, запрос в поисковик, а там уже сайты для всех вероятно знакомые.
  Посмотрел мельком на Ваше выполнение, а там у Вас с ноликами, для заполнения отсутствия цифр, у меня так не получилось почему-то, хотя я об этом думал
  
  Ответить

Максим:

1 мая 2021 в 19:32

Владимир, очень интересный код. Это отличный пример того, зачем нужны практические задачи и комментарии с решениями.

Для себя из него подчерпнул сразу несколько практичных фишек:
1. Структура SYSTEMTIME Time для работы со временем.
2. Управляющий символ "\r" для перезаписи строки в цикле.
3. Функция _kbhit() для контроля нажатия клавиши.
4. Функция system("color 1e") для настройки цвета фона и шрифта в консоли.

В свою очередь хотел бы поделиться способом вывода времени.

Чтобы выводить время в формате "01:01:01" многие используют циклы проверки (число < 10), чтобы потом дорисовать к цифрам "0".

Из урока 209 подчерпнул функцию-заполнитель std::cout.fill('char').
В связке с std::setw(2) и std::right, позволяет автоматически дорисовывать "0" в часах, когда значение часов, минут или секунд меньше 10.

Пример:

#include <iomanip>      // для std::setw(2), std::right

// определяем символ-заполнитель для формата часов "01:01:01" (достаточно записать один раз в программе)
std::cout.fill('0');

// вывод "Часов" в одной строке
std::cout << "Текущее время:\t";
std::cout << std::setw(2) << std::right << Time.wHour << ":";
std::cout << std::setw(2) << std::right << Time.wMinute << ":";
std::cout << std::setw(2) << std::right << Time.wSecond << "\r";

1

2

3

4

5

6

7

8

9

10

#include <iomanip> // для std::setw(2), std::right

// определяем символ-заполнитель для формата часов "01:01:01" (достаточно записать один раз в программе)

std::cout.fill('0');

// вывод "Часов" в одной строке

std::cout << "Текущее время:\t";

std::cout << std::setw(2) << std::right << Time.wHour << ":";

std::cout << std::setw(2) << std::right << Time.wMinute << ":";

std::cout << std::setw(2) << std::right << Time.wSecond << "\r";

Ответить

Alexandr:

17 сентября 2019 в 14:23

Задание №3:

#include <iostream>
#include <fstream>
#include <vector>
#include <string>
#include <cstdlib>

class Students {
private:
	struct Student {
		struct Grade
		{
			int math;
			int inform;
			int phys;
		};
		std::string surname;
		std::string name;
		std::string pantronymic;
		Grade grade;
	};

	std::vector<Student> data;
	std::ifstream ifs;

	void readData() {
		int start = 0, space = 0;
		for (char a; ifs.get(a);) {
			if (start != 0) {
				if (a != '\n') {
					if (space == 5) {
						if (a != ' ') {
							data.at(start - 1).grade.inform = std::atoi(( const char*) & a);
						}
						else {
							++space;
						}
					}
					if (space == 4) {
						if (a != ' ') {
							data.at(start - 1).grade.phys = std::atoi(( const char*) & a);
						}
						else {
							++space;
						}
					}
					if (space == 3) {
						if (a != ' ') {
							data.at(start - 1).grade.math = std::atoi(( const char*) & a);
						}
						else {
							++space;
						}
					}
					if (space == 2) {
						if (a != ' ') {
							data.at(start - 1).pantronymic += a;
						}
						else {
							++space;
						}
					}
					if (space == 1) {
						if (a != ' ') {
							data.at(start - 1).name += a;
						}
						else {
							++space;
						}
					}
					if (space == 0) {
						if (a != ' ') {
							data.at(start - 1).surname += a;
						}
						else {
							++space;
						}
					}
				}
				else {
					++start;
					space = 0;
				}
			}
			else {
				if (a == '\n') {
					++start;
				}
				if (a != '\n') {
					data.resize(std::atoi(( const char*) & a));
				}
			}
		}
	}
	void sortData() {
		for (int index_1 = 0; index_1 < data.size() - 1; ++index_1) {
			float midgradeindex_1 = (data.at(index_1).grade.inform + data.at(index_1).grade.math + data.at(index_1).grade.phys) / 3;
			bool over = true;
			for (int index_2 = index_1 + 1; index_2 < data.size(); ++index_2) {
				float midgradeindex_2 = (data.at(index_2).grade.inform + data.at(index_2).grade.math + data.at(index_2).grade.phys) / 3;
				if (midgradeindex_2 > midgradeindex_1) {
					over = false;
					std::swap(data.at(index_1), data.at(index_2));
				}
			}
			if (over) {
				break;
			}
		}
	}

public:
	Students() {
		ifs.open("F:\\input_data.txt", std::ios::in);
		readData();
		sortData();
	}

	void printData() {
		for (auto& stuedents : data) {
			std::cout << stuedents.surname << " " << stuedents.name << " " << stuedents.pantronymic << " - " << "Информатика: " << stuedents.grade.inform
				<< " Математика: " << stuedents.grade.math << " Физика: " << stuedents.grade.phys << std::endl;
		}
	}
};

void main() {
	setlocale(0, "");
	Students students;
	students.printData();
}

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

78

79

80

81

82

83

84

85

86

87

88

89

90

91

92

93

94

95

96

97

98

99

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

#include <iostream>

#include <fstream>

#include <vector>

#include <string>

#include <cstdlib>

class Students {

private:

struct Student {

struct Grade

{

int math;

int inform;

int phys;

};

std::string surname;

std::string name;

std::string pantronymic;

Grade grade;

};

std::vector<Student> data;

std::ifstream ifs;

void readData() {

int start = 0, space = 0;

for (char a; ifs.get(a);) {

if (start != 0) {

if (a != '\n') {

if (space == 5) {

if (a != ' ') {

data.at(start - 1).grade.inform = std::atoi(( const char*) & a);

}

else {

++space;

}

if (space == 4) {

if (a != ' ') {

data.at(start - 1).grade.phys = std::atoi(( const char*) & a);

}

else {

++space;

}

if (space == 3) {

if (a != ' ') {

data.at(start - 1).grade.math = std::atoi(( const char*) & a);

}

else {

++space;

}

if (space == 2) {

if (a != ' ') {

data.at(start - 1).pantronymic += a;

}

else {

++space;

}

if (space == 1) {

if (a != ' ') {

data.at(start - 1).name += a;

}

else {

++space;

}

if (space == 0) {

if (a != ' ') {

data.at(start - 1).surname += a;

}

else {

++space;

}

else {

++start;

space = 0;

}

else {

if (a == '\n') {

++start;

}

if (a != '\n') {

data.resize(std::atoi(( const char*) & a));

}

void sortData() {

for (int index_1 = 0; index_1 < data.size() - 1; ++index_1) {

float midgradeindex_1 = (data.at(index_1).grade.inform + data.at(index_1).grade.math + data.at(index_1).grade.phys) / 3;

bool over = true;

for (int index_2 = index_1 + 1; index_2 < data.size(); ++index_2) {

float midgradeindex_2 = (data.at(index_2).grade.inform + data.at(index_2).grade.math + data.at(index_2).grade.phys) / 3;

if (midgradeindex_2 > midgradeindex_1) {

over = false;

std::swap(data.at(index_1), data.at(index_2));

}

if (over) {

break;

}

public:

Students() {

ifs.open("F:\\input_data.txt", std::ios::in);

readData();

sortData();

}

void printData() {

for (auto& stuedents : data) {

std::cout << stuedents.surname << " " << stuedents.name << " " << stuedents.pantronymic << " - " << "Информатика: " << stuedents.grade.inform

<< " Математика: " << stuedents.grade.math << " Физика: " << stuedents.grade.phys << std::endl;

}

};

void main() {

setlocale(0, "");

Students students;

students.printData();

}

Ответить

Shom:

17 сентября 2019 в 13:14

Задание №3.

/*—————————————————————————————————
Текстовой файл "students.txt":
*****************************************************
10 Иванов Сергей Петрович 3 3 4 Фёдоров Александр Сергеевич 4 3 5 Кирк Джим Тибальд 4 4 4 Вайт Волтер Валерьянович 5 5 4 Бинг Чендлер Чарльзович 4 3 4 Петров Василий Олегович 3 3 3 Васечкин Пётр Александрович 3 3 4 Барашкова Настясья Филлиповна 3 4 3 Сполдинг Дуглас Леонардович 4 4 4 Сполдинг Томас Леонардович 4 5 5

****************************************************
————————————————————————————————-*/

#include <iostream>
#include <fstream>
#include <wchar.h>    // для работы с Кириллицей;
#include <vector>
#include <iomanip>
#include <codecvt>   // Для преобразования кодировки потока;


struct Data          // Структура данных студента; 
{
    std::wstring fullName;
    size_t math, 
           physics,
           compSciense;    
};

class Student
{
private:
    Data m_data;                     // Объект структуры;
    std::vector<Data> m_students;    // Массив структур данных;
    
    
public:
    Student()
    {
        readData();
        sort();
        print();        
    }
    
    void readData()                                  // Метод чтения данных
    {                                                //      из файла;
        std::wifstream in;        
        in.open("../students.txt");
        if (!in.is_open())                          // Если файл не откылся ...
        {
            std::wcout << L"Файл не найден.\n";
            in.close();
            exit(0);                               // ... завершаем программу; 
        }
                                              // Преобразование кодировки потока;
        in.imbue(std::locale(in.getloc(), new std::codecvt_utf8<wchar_t>));
        std::wstring line;
                
        while (std::getline(in, line))       // Чтение из потока;
        {        
             std::wstring surname{L"0"},
                          name,
                          patronymic,
                          fullName;                       
                       
             size_t       math, 
                          physics,
                          compSciense;               
             
             in >> surname >> name >> patronymic >>     // Запись во временные
                    math >> physics >> compSciense;     //       переменные;
            
             fullName = surname + L" " + name + L" " + patronymic;
              
             if (surname != L"0")          // Для исключения дублирования записи
             {                             //              последней строки;
                  m_students.push_back(m_data = {fullName, math, physics, 
                                                             compSciense});
             }                            
        }
        in.close();        
    }
    
    void sort()                       // Метод сортировки массива;
    {
        std::vector<Data> &arr = m_students;

        for (unsigned int iii = 0; iii < arr.size() - 1; iii++) 
        {
            for (unsigned int jjj = 0; jjj < arr.size() - iii - 1; jjj++) 
            {
                if ((arr.at(jjj+1).math + arr.at(jjj+1).physics +arr.at(jjj+1).compSciense) > 
                     (arr.at(jjj).math + arr.at(jjj).physics +arr.at(jjj).compSciense) )
                    
                    std::swap(arr.at(jjj), arr.at(jjj+1));
            }
        }
    }
    
    void print()                      // Метод вывода данных на экран;
    {        
         std::wcout << L"\t\t\tСтуденты \n";
         std::wcout << std::setw(3)    << std::left  << L"№" << std::right <<
                       std::setw(13)   <<  L"ФИО"    << std::setw(30)      <<
                       L"Математика "  << L"Физика " << L"Информатика \n";
                       
         for (int iii{0}; iii<65; ++iii) std::wcout << L"-";
         std::wcout << L"\n";
         
         size_t count{1};         
         for (const auto& w : m_students)
         { 
             std::wcout << std::setw(3) << std::left     << count <<
                          std::setw(32) << w.fullName    <<                
                          std::right    << std::setw(5)  << w.math <<
                          std::setw(9)  << w.physics     <<
                          std::setw(9)  << w.compSciense << "\n";
             ++count;            
         }
        std::wcout << L"\n";   
    }
};

int main()
{        
     setlocale(LC_ALL, "");
     
     Student s; 
     return 0;
}

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

78

79

80

81

82

83

84

85

86

87

88

89

90

91

92

93

94

95

96

97

98

99

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

#include <iostream>

#include <fstream>

#include <wchar.h> // для работы с Кириллицей;

#include <vector>

#include <iomanip>

#include <codecvt> // Для преобразования кодировки потока;

struct Data // Структура данных студента;

{

std::wstring fullName;

size_t math,

physics,

compSciense;

};

class Student

{

private:

Data m_data; // Объект структуры;

std::vector<Data> m_students; // Массив структур данных;

public:

Student()

{

readData();

sort();

print();

}

void readData() // Метод чтения данных

{ // из файла;

std::wifstream in;

in.open("../students.txt");

if (!in.is_open()) // Если файл не откылся ...

{

std::wcout << L"Файл не найден.\n";

in.close();

exit(0); // ... завершаем программу;

}

// Преобразование кодировки потока;

in.imbue(std::locale(in.getloc(), new std::codecvt_utf8<wchar_t>));

std::wstring line;

while (std::getline(in, line)) // Чтение из потока;

{

std::wstring surname{L"0"},

name,

patronymic,

fullName;

size_t math,

physics,

compSciense;

in >> surname >> name >> patronymic >> // Запись во временные

math >> physics >> compSciense; // переменные;

fullName = surname + L" " + name + L" " + patronymic;

if (surname != L"0") // Для исключения дублирования записи

{ // последней строки;

m_students.push_back(m_data = {fullName, math, physics,

compSciense});

}

in.close();

}

void sort() // Метод сортировки массива;

{

std::vector<Data> &arr = m_students;

for (unsigned int iii = 0; iii < arr.size() - 1; iii++)

{

for (unsigned int jjj = 0; jjj < arr.size() - iii - 1; jjj++)

{

if ((arr.at(jjj+1).math + arr.at(jjj+1).physics +arr.at(jjj+1).compSciense) >

(arr.at(jjj).math + arr.at(jjj).physics +arr.at(jjj).compSciense) )

std::swap(arr.at(jjj), arr.at(jjj+1));

}

void print() // Метод вывода данных на экран;

{

std::wcout << L"\t\t\tСтуденты \n";

std::wcout << std::setw(3) << std::left << L"№" << std::right <<

std::setw(13) << L"ФИО" << std::setw(30) <<

L"Математика " << L"Физика " << L"Информатика \n";

for (int iii{0}; iii<65; ++iii) std::wcout << L"-";

std::wcout << L"\n";

size_t count{1};

for (const auto& w : m_students)

{

std::wcout << std::setw(3) << std::left << count <<

std::setw(32) << w.fullName <<

std::right << std::setw(5) << w.math <<

std::setw(9) << w.physics <<

std::setw(9) << w.compSciense << "\n";

++count;

}

std::wcout << L"\n";

}

};

int main()

{

setlocale(LC_ALL, "");

Student s;

return 0;

}

Ответить

Shom:

12 сентября 2019 в 13:11

Задание №2.

#include <iostream>
#include <string>

int main()
{    
    std::cout << "Введите строку: ";
    std::string  number;
    std::cin  >> number;
    
    for (auto w : number)
    {
        if ( w < 48 || w > 57)
        {
            std::cout << number << " не является целым числом\n";
            return 0;
        }
    }    
    std::cout << number << " целое число\n";
    
    return 0;
}

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

#include <iostream>

#include <string>

int main()

{

std::cout << "Введите строку: ";

std::string number;

std::cin >> number;

for (auto w : number)

{

if ( w < 48 || w > 57)

{

std::cout << number << " не является целым числом\n";

return 0;

}

std::cout << number << " целое число\n";

return 0;

}

Ответить

Shom:

11 сентября 2019 в 19:39

Задание №1.

#include <iostream>
#include <unistd.h>           // Для sleep();
#include <termios.h>          // Для работы с терминалом linux;
#include <thread>             // Для многопоточности;

void getch()                    // Функция "отлова" нажатия клавиши;                    
{
   struct termios oldt,                          // Структуры для хранения
                  newt;                          //       состояния терминала;
   int ch{0};                                    // Переменная для хранения кода нажатой клавиши;
   tcgetattr( STDIN_FILENO, &oldt );             // Сохраняем состояние терминала в структуру;
   newt = oldt;                                  // Копируем структуру;
   newt.c_lflag &= ~( ICANON | ECHO );           // Отключаем канонический ввод и вывод на экран;
   tcsetattr( STDIN_FILENO, TCSANOW, &newt );    // Устанавливаем состояние терминала из структуры;
   ch = getchar();                               // "Ловим" нажатие клавиши и записываем в переменную;
   tcsetattr( STDIN_FILENO, TCSANOW, &oldt );    // Возвращаем терминалу обычное состояние;   
   if (ch) exit(0);                              // Завершаем программу;  
}

void watch()
{
    size_t timeToShow{180};                      // Длительность отображения часов в секундах;
    for (size_t iii{0}; iii<timeToShow; ++iii)
    {
        system("date +%T");                     //  Комманда вывода текущего времени в консоли;
        sleep(1);                               //  Пауза 1 сек.;
        system("clear");                        //  Очиска консоли; 
    }
    exit(0);                                    //  Завершение программы;
}

int main()
{    
    std::thread t1(watch);                     // Объект первого потока (часы);
    std::thread t2(getch);                     // Объект второго потока ( ожидание 
                                               //     и обработка ввода символа );       
    t1.join();                                 // Блокируем дальнейшее выполнение
    t2.join();                                 //    main() до завершения работы потоков;

    return 0;
}

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

#include <iostream>

#include <unistd.h> // Для sleep();

#include <termios.h> // Для работы с терминалом linux;

#include <thread> // Для многопоточности;

void getch() // Функция "отлова" нажатия клавиши;

{

struct termios oldt, // Структуры для хранения

newt; // состояния терминала;

int ch{0}; // Переменная для хранения кода нажатой клавиши;

tcgetattr( STDIN_FILENO, &oldt ); // Сохраняем состояние терминала в структуру;

newt = oldt; // Копируем структуру;

newt.c_lflag &= ~( ICANON | ECHO ); // Отключаем канонический ввод и вывод на экран;

tcsetattr( STDIN_FILENO, TCSANOW, &newt ); // Устанавливаем состояние терминала из структуры;

ch = getchar(); // "Ловим" нажатие клавиши и записываем в переменную;

tcsetattr( STDIN_FILENO, TCSANOW, &oldt ); // Возвращаем терминалу обычное состояние;

if (ch) exit(0); // Завершаем программу;

}

void watch()

{

size_t timeToShow{180}; // Длительность отображения часов в секундах;

for (size_t iii{0}; iii<timeToShow; ++iii)

{

system("date +%T"); // Комманда вывода текущего времени в консоли;

sleep(1); // Пауза 1 сек.;

system("clear"); // Очиска консоли;

}

exit(0); // Завершение программы;

}

int main()

{

std::thread t1(watch); // Объект первого потока (часы);

std::thread t2(getch); // Объект второго потока ( ожидание

// и обработка ввода символа );

t1.join(); // Блокируем дальнейшее выполнение

t2.join(); // main() до завершения работы потоков;

return 0;

}

Ответить

Анастасия:

15 января 2020 в 20:28

Какой короткий и в то же время богатый незнакомыми терминами код! Жаль, что он не годится для Windows, у меня компилятор выдаёт ошибку "Не удается открыть файл включение: unistd.h: No such file or directory"

Ответить
1. Shom:
  
  16 января 2020 в 10:00
  
  Можете скачать этот unistd.h в папку с проектом) Но, по большому счёту, в этом нет необходимости — на Виндовс есть своя функция Sleep(). Да и вообще, на Виндовс программа бы получилась короче — можно было бы самописную функцию void getch() заменить стандартной библиотечной функцией getch().
  
  Ответить

Илья:

28 июля 2019 в 09:34

Задание №2:

#include <iostream>
#include "Windows.h"
#include <sstream>
#include <string>

int main()
{
	SetConsoleCP(1251);
	SetConsoleOutputCP(1251);
	
	std::cout << "Введите строку: ";
	std::string userStr;
	getline(std::cin, userStr);
	std::stringstream bufferStr(userStr);
	double number;
	if (!(bufferStr >> number))
	{
		std::cout << "Не является целым числом" << std::endl;
	}
	else if ((number - static_cast<int>(number) > 0))
	{
		std::cout << "Не является целым числом" << std::endl;
	}
	else
	{
		std::cout << "Является целым числом: ";
		std::cout << number << std::endl;
	}

	return 0;
}

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

#include <iostream>

#include "Windows.h"

#include <sstream>

#include <string>

int main()

{

SetConsoleCP(1251);

SetConsoleOutputCP(1251);

std::cout << "Введите строку: ";

std::string userStr;

getline(std::cin, userStr);

std::stringstream bufferStr(userStr);

double number;

if (!(bufferStr >> number))

{

std::cout << "Не является целым числом" << std::endl;

}

else if ((number - static_cast<int>(number) > 0))

{

std::cout << "Не является целым числом" << std::endl;

}

else

{

std::cout << "Является целым числом: ";

std::cout << number << std::endl;

}

return 0;

}

Ответить

Илья:

28 июля 2019 в 09:15

Задание №1:

#include <iostream>
#include "Windows.h"
#include <chrono>

class Timer
{
private:
	// Псевдонимы типов используются для удобного доступа к вложенным типам
	using clock_t = std::chrono::high_resolution_clock;
	using second_t = std::chrono::duration<double, std::ratio<1> >;

	std::chrono::time_point<clock_t> m_beg;

public:
	Timer() : m_beg(clock_t::now())
	{
	}

	void reset()
	{
		m_beg = clock_t::now();
	}
	double elapsed() const
	{
		return std::chrono::duration_cast<second_t>(clock_t::now() - m_beg).count();
	}
};


int main(void)
{
	SetConsoleCP(1251);
	SetConsoleOutputCP(1251);
	
	std::cout << "Введите время, которое должен работать таймер(сек): ";
	uint32_t userTime;
	std::cin >> userTime;
	Timer time;
	double startTime = time.elapsed();

	while (true)
	{
		if ((time.elapsed() - startTime > 1) && (userTime > 0))
		{
			startTime = time.elapsed();
			--userTime;
			std::cout << (userTime / 60) << ':' << (userTime % 60) << std::endl;
		}
	}
	std::cout << '\a' << std::endl;
	return 0;
}

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

#include <iostream>

#include "Windows.h"

#include <chrono>

class Timer

{

private:

// Псевдонимы типов используются для удобного доступа к вложенным типам

using clock_t = std::chrono::high_resolution_clock;

using second_t = std::chrono::duration<double, std::ratio<1> >;

std::chrono::time_point<clock_t> m_beg;

public:

Timer() : m_beg(clock_t::now())

{

}

void reset()

{

m_beg = clock_t::now();

}

double elapsed() const

{

return std::chrono::duration_cast<second_t>(clock_t::now() - m_beg).count();

}

};

int main(void)

{

SetConsoleCP(1251);

SetConsoleOutputCP(1251);

std::cout << "Введите время, которое должен работать таймер(сек): ";

uint32_t userTime;

std::cin >> userTime;

Timer time;

double startTime = time.elapsed();

while (true)

{

if ((time.elapsed() - startTime > 1) && (userTime > 0))

{

startTime = time.elapsed();

--userTime;

std::cout << (userTime / 60) << ':' << (userTime % 60) << std::endl;

}

std::cout << '\a' << std::endl;

return 0;

}

Ответить

Илья:

28 июля 2019 в 09:24

Вот так правильнее, если нажать пробел, программа завершится досрочно (подключена библиотека SFML)

#include <iostream> #include "Windows.h" #include <chrono> #include <SFML\Graphics.hpp> class Timer { private: // Псевдонимы типов используются для удобного доступа к вложенным типам using clock_t = std::chrono::high_resolution_clock; using second_t = std::chrono::duration<double, std::ratio<1> >; std::chrono::time_point<clock_t> m_beg; public: Timer() : m_beg(clock_t:

Часть №7: Практические задания по С++

Easy: Задание №1

Medium: Задание №2

Hard: Задание №3

Комментариев: 36