Как составит программу на языке программирования

В этой главе мы напишем первую программу на C++ и научимся печатать и считывать с клавиатуры строки и числа.

Функция main

Пожалуй, самая простая и короткая программа на C++ — это программа, которая ничего не делает. Она выглядит так:

int main() {
    return 0;
}

Здесь определяется функция с именем main, которая не принимает никаких аргументов (внутри круглых скобок ничего нет) и не выполняет никаких содержательных команд. В каждой программе на C++ должна быть ровно одна функция main — с неё начинается выполнение программы.

У функции указан тип возвращаемого значения int (целое число), и она возвращает 0 — в данном случае это сообщение для операционной системы, что программа выполнилась успешно. И наоборот, ненулевой код возврата означает, что при выполнении возникла ошибка (например, программа получила некорректные входные данные).

Для функции main разрешается не писать завершающий return 0, чем мы и будем пользоваться далее для краткости. Поэтому самую короткую программу можно было бы написать вот так:

int main() {
}

Hello, world!

Соблюдая традиции, напишем простейшую программу на C++ — она выведет приветствие в консоль:

#include <iostream>

int main() {
    std::cout << "Hello, world!n";
    return 0;
}

Разберём её подробнее.

Директива #include <iostream> подключает стандартный библиотечный заголовочный файл для работы с потоками ввода-вывода (input-output streams). Для печати мы используем поток вывода std::cout, где cout расшифровывается как character output, то есть «символьный вывод».

В теле функции main мы передаём в std::cout строку Hello, world! с завершающим переводом строки n. В зависимости от операционной системы n будет преобразован в один или в два управляющих байта с кодами 0A или 0D 0A соответственно.

Инструкции внутри тела функции завершаются точками с запятой.

Компиляция из командной строки

Вы можете запустить эту программу из какой-нибудь IDE. Мы же покажем, как собрать её в консоли Linux с помощью компилятора clang++.

Пусть файл с программой называется hello.cpp. Запустим компилятор:

$ clang++ hello.cpp -o hello

В результате мы получим исполняемый файл с именем hello, который теперь можно просто запустить. Он напечатает на экране ожидаемую фразу:

$ ./hello
Hello, world!

Если опцию -o не указать, то сгенерированный исполняемый файл будет по умолчанию назван a.out. В дальнейшем для простых примеров мы будем использовать краткую форму записи команды:

$ clang++ hello.cpp && ./a.out
Hello, world!

С её помощью мы компилируем программу и в случае успеха компиляции сразу же запускаем.

Комментарии

Комментарии — это фрагменты программы, которые игнорируются компилятором и предназначены для программиста. В C++ есть два вида комментариев — однострочные и многострочные:

int main() {  // однострочный комментарий продолжается до конца строки

/* Пример
   многострочного
   комментария */
}

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

Хорошо: комментировать, что делает библиотека, функция или класс или почему этот код написан именно так.

Плохо: комментировать, что происходит на отдельной строчке. Это признак того, что код можно написать лучше.

Библиотеки и заголовочные файлы

Библиотека — это код, который можно переиспользовать в разных программах. В стандарт языка C++ входит спецификация так называемой стандартной библиотеки, которая поставляется вместе с компилятором. Она содержит различные структуры данных (контейнеры), типовые алгоритмы, средства ввода-вывода и т. д. Конструкции из этой библиотеки предваряются префиксом std::, который обозначает пространство имён.

Чтобы воспользоваться теми или иными библиотечными конструкциями, в начале программы надо подключить нужные заголовочные файлы. Так, в программе, которая печатала Hello, world!, нам уже встречался заголовочный файл iostream и конструкция std::cout из стандартной библиотеки.

Для C++ существует также множество сторонних библиотек. Наиболее известной коллекцией сторонних библиотек для C++ является Boost.

Ошибки компиляции

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

Рассмотрим пример такой программы:

#include <iostream>

int main() {
    cout << "Hello, worldn"

Компилятор может выдать такие сообщения:

$ clang++ hello.cpp
hello.cpp:4:5: error: use of undeclared identifier 'cout'; did you mean 'std::cout'?
    cout << "Hello, world!n"
    ^~~~
    std::cout

hello.cpp:4:30: error: expected ';' after expression
    cout << "Hello, world!n"
                             ^
                             ;

hello.cpp:5:1: error: expected '}'
^
a.cpp:3:12: note: to match this '{'
int main() {
           ^
3 errors generated.

Первая ошибка — вместо std::cout мы написали cout. Вторая ошибка — не поставили точку запятой после "Hello, world!n". Наконец, третья – не закрыли фигурную скобку с телом функции.

Ошибки компиляции (compile errors) следует отличать от возможных ошибок времени выполнения (runtime errors), которые происходят после запуска программы и, как правило, зависят от входных данных, неизвестных во время компиляции.

Отступы и оформление кода

Фрагменты программы на C++ могут быть иерархически вложены друг в друга. На верхнем уровне находятся функции, внутри них написаны их тела, в теле могут быть составные операторы, и так далее.

Среди программистов есть соглашение — писать внутренние блоки кода с отступами вправо: компилятор полностью игнорирует эти отступы, а код читать удобнее. Мы будем использовать отступы в четыре пробела. Также мы будем придерживаться стиля оформления кода, принятого в Яндексе. Имена переменных мы будем писать с маленькой буквы, имена функций и классов — с большой (если речь не идёт о конструкциях стандартной библиотеки, где действуют другие соглашения).

Переменные

Любая содержательная программа так или иначе обрабатывает данные в памяти. Переменная — это именованный блок данных определённого типа. Чтобы определить переменную, нужно указать её тип и имя. В общем виде это выглядит так:

Type name;

где вместо Type — конкретный тип данных (например, строка или число), а вместо name — имя переменной. Имена переменных должны состоять из латинских букв, цифр и знаков подчёркивания и не должны начинаться с цифры. Также можно в одной строке определить несколько переменных одного типа:

Type name1 = value1, name2 = value2, name3 = value3;

Например:

#include <string>  // библиотека, в которой определён тип std::string

int main() {
    // Определяем переменную value целочисленного типа int
    int value;

    // Определяем переменные name и surname типа std::string (текстовая строка)
    std::string name, surname;
}

В этом примере мы используем встроенный в язык тип int (от слова integer — целое число) и поставляемый со стандартной библиотекой тип std::string. (Можно было бы использовать для строк встроенный тип с массивом символов, но это неудобно.)

Тип переменной должен быть известен компилятору во время компиляции.

От типа зависит:

• сколько байтов памяти потребуется для хранения данных;
• как интерпретировать эти байты;
• какие операции с этой переменной возможны.

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

Важно понимать, что тип остаётся с переменной навсегда. Например, присвоить целочисленной переменной строку не получится — это вызовет ошибку компиляции:

int main() {
    int value;
    value = 42;  // OK
    value = "Hello!";  // ошибка компиляции!
}

Переменные можно сразу проинициализировать значением. В С++ есть много разных способов инициализации. Нам пока будет достаточно способа, который называется copy initialization:

#include <string>

int main() {
    int value = 42;
    std::string title = "Bjarne Stroustrup";
}

Если переменная, была объявлена, но нигде дальше не использовалась, то компилятор выдаёт об этом предупреждение. При проверке решений мы используем опцию -Werror, которая считает предупреждения компилятора ошибками компиляции.

Потоковый ввод и вывод

Поток — это абстракция для чтения и записи последовательности данных в форматированном виде.

Записывать данные можно на экран консоли, в файл, буфер в памяти или в строку. Считывать их можно с клавиатуры, из файла, из памяти. Причём с каждым таким «устройством» можно связать свой поток.

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

В программе Hello, world! нам уже встречался поток вывода std::cout, по умолчанию связанный с экраном консоли. Познакомимся с потоком ввода std::cin, связанным с клавиатурой. Для его использования нужен тот же заголовочный файл iostream.

Рассмотрим программу, которая спрашивает имя пользователя и печатает персональное приветствие:

#include <iostream>
#include <string>

int main() {
    std::string name;  // объявляем переменную name
    std::cout << "What is your name?n";
    std::cin >> name;  // считываем её значение с клавиатуры
    std::cout << "Hello, " << name << "!n";
}

Обратите внимание на направление угловых скобок в этом примере — они условно показывают направление потока данных. При печати данные выводятся на экран, и стрелки направлены от текста к cout. При вводе данные поступают с клавиатуры, и стрелки направлены от cin к переменной.

В нашем примере в переменную name считается одно слово, которое будет выведено в ответном сообщении. Пример работы программы:

What is your name?
Alice
Hello, Alice!

Однако если ввести строку из нескольких слов с пробелами, то в name запишется только первое слово:

$ ./a.out
What is your name?
Alice Liddell
Hello, Alice!

Дело в том, что cin читает поток данных до ближайшего пробельного разделителя (пробела, табуляции, перевода строки или просто конца файла). Чтобы считать в строковую переменную всю строчку целиком (не включая завершающий символ перевода строки), нужно использовать функцию std::getline из заголовочного файла string:

#include <iostream>
#include <string>

int main() {
    std::string name;
    std::getline(std::cin, name);
    std::cout << "Hello, " << name << "!n";
}

В этом примере мы печатаем в одном выражении друг за другом несколько строк ("Hello, ", name и "!n"), разделённых угловыми скобками <<. Таким образом, cin и cout позволяют кратко считывать и печатать несколько объектов одной командой.

Например, считывание нескольких чисел целого типа, набранных через пробельные разделители, может выглядеть так:

int main() {
    int a;
    int b;
    int c;
    std::cin >> a >> b >> c;
}

Напечатать их значения можно следующим образом:

std::cout << a << " " << b << " " << c << "n";

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

Была ли эта статья полезной?

Первый опыт написания полноценной программы

Каждый начинающий программист мечтает реализовать свой собственный проект. Не написать простенький код, по заданию преподавателя, а воплотить в жизнь свои идеи. Так и я, изучая C++ 3-4 месяца, решился попробовать разработать макет электронного журнала для преподавателей.

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

По итогу, пришел к выводу, что в программе потребуется реализовать:

1. Регистрацию (Reg),

2. Авторизацию (Authon),

3. Выбор группы (GroupSelection),

4. Возможность выставлять оценки (Grades),

5. Возможность выставлять посещаемость (Attendance),

6. Возможность писать комментарии к датам (Comment),

7. Возможность устанавливать dedlin’ы (Deadline).

Для понимания логики работы программы, отражения принципов взаимодействия с ней, упрощения дальнейшего написания кода, была создана полная блок-схема.

Аналогично, были созданы блок схемы для каждой функции.

Написание кода программы

Первым шагом написания программы является добавления необходимых заголовочных файлов, а именно:

1. iostream — заголовочный файл с классами, функциями и переменными для организации ввода-вывода.

2. string —  это заголовочный файл для взаимодействия с
   классами string (строками).

3. fstream — заголовочный файл, включающий набор классов, методов и функций, которые предоставляют интерфейс для чтения/записи данных из/в файл.

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

std::string nameofgroup;

Чтобы удобно группировать данных в одной переменной для каждого объекта, который оперирует этими данными, мною было объявлено несколько классов, а именно:

Класс данных о преподавателе – DataofTeature.

class DataofTeature
{
public:
	std::string name; //имя преподавателя
	std::string surname; //фамилия преподавателя
	std::string patronymic; //отчество преподавателя
	std::string login; //логин преподавателя
	std::string password; //пароль преподавателя
};

Класс данных о студенте – DataofStudent.

class DataofStudent
{
public:
	std::string group; //название группы студента
	std::string name; //имя студента
	std::string surname; //фамилия студента
};

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

Reg

Функция Reg реализует полноценную регистрацию, с записью данных о пользователе в текстовый файл.

В ходе выполнения функции, пользователю предлагается ввести ФИО, логин и пароль. После получения программой логина, проверяется его наличие в системе, если логин совпадает с ранее записанным в базу логинов, то пользователя предлагается ввести логин повторно. Как только программа получает ФИО, пароль и уникальный логин, происходит запись логина в базу для логинов (при открытие базы данных используется режим открытия ios_base::app, позволяющий открыть файл для записи в конец файла, при этом, сохраняя ранее записанные данные), создание специализированного файла для регистрационных данных пользователя, и запись в него ФИО, аналогично создается специальный файл для хранения логина и пароля конкретного пользователя. Формирования уникальных файлов происходит по принципу сложения строк. Например, path=path+teature1.login+txt, где path-путь к директории, в которой хранятся файлы программы, teature1.login – уникальный логин пользователя, txt- строка, хранящая в себе “.txt”.

void Reg()
{
	std::string path = "C:\journal\regdata", datalog = "C:\journal\logdata.txt", txt = ".txt", user = "C:\journal\", delfile = "C:\journal\delfile.txt"; //объявление переменных типа string
	bool flag = 1; //объявление переменной типа bool
	DataofTeature teature1; //объявление переменной класса DataofTeature
	std::ofstream fout; //объявление переменной класса ofstream
	std::ifstream fin; //объявление переменной класса ifstream
	std::cout << "tttРегистрация:n"; //ввод даных, необходимых для регистрации
	std::cout << "Введите фамилию: ";
	std::cin >> teature1.surname;
	std::cout << "Введите имя: ";
	std::cin >> teature1.name;
	std::cout << "Введите отчество: ";
	std::cin >> teature1.patronymic;
	std::cout << "Введите логин: ";
	std::cin >> teature1.login;
	while (flag)
	{
		bool flag2 = 0;
		fin.open(datalog);
		if (fin.is_open())
		{
			std::string data = "";
			while (!fin.eof())
			{
				std::getline(fin, data);
				if (teature1.login == data)		//проверка на существование данного логина в файле
				{
					flag2 = 1;
					flag = 1;
				}
			}
		}
		else
		{
			std::cout << "ERROR"; //Файл не удалось создать или открыть
		}
		if (flag2)
		{
			std::cout << "Данный логин уже существует, придумайте другой логин: "; //прозьба ввести логин повторно, если введенный до этого уже существует
			std::cin >> teature1.login;
			flag = 1;
		}
		else
		{
			flag = 0; //изменение булевой переменной для выхода из цыкла
		}
		fin.close();
	}
	path = path + teature1.login + txt; //формирование пути, для создания файла с ФИО аккаунта
	fout.open(path);
	if (fout.is_open())
	{
		fout << teature1.surname << "n";
		fout << teature1.name << "n";			//запись данных в файл
		fout << teature1.patronymic << "n";
	}
	else
	{
		std::cout << "ERROR"; //Файл не удалось создать или открыть
	}
	fout.close();
	std::cout << "Введите пароль: ";
	std::cin >> teature1.password;		//ввод пароля
	fout.open(datalog, std::ios_base::app); //открыть файл для записи в конец файла
	if (fout.is_open())
	{
		fout << teature1.login << "n"; //запись данных в файл
	}
	else
	{
		std::cout << "ERROR"; //Файл не удалось создать или открыть
	}
	fout.close();
	user = user + teature1.login + txt; //формирование пути хранения логина и пароля
	fout.open(user); //открытия файла
	if (fout.is_open())
	{
		fout << teature1.login << "n";
		fout << teature1.password << "n";		//запись данных в файл
	}
	else
	{
		std::cout << "ERROR"; //Файл не удалось создать или открыть
	}
	fout.close();
}

Authon

Функция Authon реализует авторизацию пользователя в программу.

В ходе выполнения функции, пользователю предлагается ввести логин и пароль. Следом идет проверка наличия логина в базе логинов, если логина в базе нет, пользователю
предлагается ввести логин повторно. Получив логин, программа открывает
специализированный файл пользователя, получая к нему путь, методом сложения
строк. В этом файле проверяется верность пароля, если пароль не совпадает, то
предлагается ввести пароль повторно. Как только все данные проверены, программа
открывает файл с ФИО пользователя и выводит на экран приветствие, используя ФИО
пользователя.

void Authon()
{
	std::string path = "C:\journal\regdata", datalog = "C:\journal\logdata.txt", txt = ".txt", user = "C:\journal\", delfile = "C:\journal\delfile.txt", login, password, filelog = ""; //объявление переменных типа string
	DataofTeature teature1; //объявление переменной класса DataofTeature
	std::ifstream fin; //объявление переменной класса ifstream
	bool flag = 1; //объявление переменной типа bool
	std::cout << "tttАвторизация:n";
	std::cout << "Введите логин: ";
	std::cin >> login;			//ввод логина
	while (flag)
	{
		bool flag2 = 0;
		fin.open(datalog);		//проверка наличия логина в базе логинов
		if (fin.is_open())
		{
			while (!fin.eof())
			{
				std::getline(fin, filelog);
				if (login == filelog)
				{
					flag = 0;
					flag2 = 0;
					break;
				}
				else
				{
					flag2 = 1;
				}
			}
		}
		else
		{
			std::cout << "ERROR"; //Файл не удалось создать или открыть
		}
		if (flag2)
		{
			std::cout << "Такого логина не существует, введите логин повторно: n";			//просьба ввести логин повторно
			std::cin >> login;
		}
		fin.close();
	}
	user = user + login + txt; //формирования пути нахождения файла с логинами и паролями
	flag = 1;
	std::cout << "Введите пароль: ";		//ввод пароля
	std::cin >> password;
	while (flag)
	{
		bool flag2 = 0;
		fin.open(user);
		if (fin.is_open())
		{
			while (!fin.eof())
			{
				std::getline(fin, filelog);
				if (password == filelog)
				{								//проверка верности пароля
					flag = 0;
					flag2 = 0;
					break;
				}
				else
				{
					flag2 = 1;
				}
			}
		}
		else
		{
			std::cout << "ERROR"; //Файл не удалось создать или открыть//
		}
		if (flag2)
		{
			std::cout << "Пароль введен не верно, попробуйте еще раз: n";		//просьба ввести пароль повторно
			std::cin >> password;
		}
		fin.close();
	}
	std::cout << "Добро пожаловать ";
	path = path + login + txt;
	fin.open(path);
	if (fin.is_open())
	{
		std::string data = "";					//вывод приветствия на экран
		while (!fin.eof())
		{
			std::getline(fin, data);
			std::cout << data << " ";
		}
	}
	else
	{
		std::cout << "ERROR"; //Файл не удалось создать или открыть
	}
	fin.close();
	std::cout << "n";
}

GroupSelection

Функция реализует полноценный выбор группы в программе.

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

void GroupSelection()
{
	DataofStudent stud1; //объявление переменных класса DataofStudent
	std::string allgroup = "", path = "C:\journal\allgroup\allgroup.txt", delfile = "C:\journal\allgroup\delfile.txt", path2 = "C:\journal\allgroup\", txt = ".txt", choice = ""; //объявление переменных типа string
	bool flag = 1; //объявление переменных типа bool
	std::ifstream fin; //объявление переменной класса ifstream
	std::ofstream fout; //объявление переменной класса ofstream
	std::cout << "Полный список групп: n";
	fin.open(path);
	if (fin.is_open())
	{
		std::string data = "";
		while (!fin.eof())
		{
			std::getline(fin, data);		//вывод а экран полного списка групп
			std::cout << "ttt" << data << "n";
		}
	}
	else
	{
		std::cout << "ERROR"; //Файл не удалось создать или открыть//
	}
	fin.close();
	std::cout << "Введите название группы, которую хотите открыть: ";
	std::cin >> stud1.group;	//ввод название необходимой группы
	while (flag)
	{
		bool flag2 = 1;
		fin.open(path);
		if (fin.is_open())
		{
			std::string data = "";
			while (!fin.eof())
			{
				std::getline(fin, data);
				if (stud1.group == data)	//проверка на наличие введенной группы в списке групп
				{
					flag2 = 0;
					flag = 0;
				}
			}
		}
		else
		{
			std::cout << "ERROR"; //Файл не удалось создать или открыть
		}
		if (flag2)
		{
			std::cout << "Данной группы не существует, введите другую группу: ";
			std::cin >> stud1.group;	//просьба ввести название группы повторно
			flag = 1;
		}
		else
		{
			flag = 0;	//изменение буливой переменной для выхода из цыкла
		}
		fin.close();
	}
	nameofgroup = stud1.group; //присваивание названия группы в глобальную переменную
}

Grades

Функция Grades реализует, простановку оценок студентам.

В ходе выполнения функции, пользователю предлагается ввести дату, за которую он хочет выставить оценку. После получения программой даты, происходит проверка на существование файла с оценками на данную дату. Если файл существует, то происходит его запись в специализированный промежуточный файл, это происходит для реализации корректной и органичной записи в файл отметок, без потерь данных. Если файл не существует, то программа копирует данные из файла со списком группы в промежуточный файл. Следом, на экран выводится полный список группы с отметками (если они есть). Пользователю предлагается ввести фамилию и имя студента, которому он хочет выставить оценку. Как только программа получает эти данные, происходит проверка на наличие данного студента в группе, если его нет, то пользователю предлагается ввести фамилию и имя повторно. После получения данных программой, происходит создание файла для оценок на данную дату (принцип нахождения пути файла и формирования его название – сложение строк). Следом, идет поиск данного студента в промежуточном файле. Принцип поиска и записи таков: если фамилия и имя не совпадает с введенными пользователем, то происходит запись этих данных в файл с оценками, если ФИ совпали, то пользователю предлагается ввести студенту оценку, полученная строчка записывается в файл с оценками. В конце работы функции, на экран выводится список группы с внесенными изменениями.

void Grades()
{
	DataofStudent student1; //объявление переменных класса DataofStudent
	std::string way = "C:\journal\allgroup\", delfile = "delfile.txt", txt = ".txt", attendance = "\grade", choice = ""; //объявление переменных типа string
	bool flag = 0, flag2 = 1; //объявление переменных типа bool
	std::ofstream fout; //объявление переменной класса ofstream
	std::ifstream fin; //объявление переменной класса ifstream
	std::cout << "Введите дату за которую вы хотите проставить оценки: ";
	std::cin >> choice;	//ввод даты 
	fin.open(way + nameofgroup + attendance + choice + txt);
	if (fin.is_open())
	{
		flag = 1;		//проверка наличия файла с оценками на данную дату
	}
	fin.close();
	if (flag)
	{
		fin.open(way + nameofgroup + attendance + choice + txt);
		fout.open(way + delfile);
		if (fin.is_open() and fout.is_open())
		{
			std::string data = "";
			while (!fin.eof())		//запись данных существующего файла в специализированный файл
			{
				std::getline(fin, data);
				fout << data << "n";
			}
		}
		else
		{
			std::cout << "ERROR"; //Файл не удалось создать или открыть
		}
		fin.close();
		fout.close();
	}
	else
	{
		fin.open(way + nameofgroup + txt);
		fout.open(way + delfile);
		if (fin.is_open() and fout.is_open())
		{
			std::string data = "";
			while (!fin.eof())
			{									//запись  в специализированный файл списка группы 
				std::getline(fin, data);
				fout << data << "n";
			}
		}
		else
		{
			std::cout << "ERROR"; //Файл не удалось создать или открыть
		}
		fin.close();
		fout.close();
	}
	fin.open(way + delfile);
	if (fin.is_open())
	{
		std::string data = "";
		while (!fin.eof())	//вывод списка группы на экран
		{
			std::getline(fin, data);
			std::cout << data << "n";
		}
	}
	else
	{
		std::cout << "ERROR"; //Файл не удалось создать или открыть
	}
	fin.close();
	std::cout << "Введите фамилию и имя студента. которому вы хотите выставить оценку: " << std::endl;
	std::cin >> student1.name;	//ввод фамили и имени студента
	while (flag2)
	{
		fin.open(way + delfile);
		if (fin.is_open())
		{
			std::string data = "";
			while (!fin.eof())
			{
				std::getline(fin, data);
				if (data == student1.name)
				{
					flag2 = 0;	//проверка наличия данно ФИ в списке группы
				}
			}
		}
		else
		{
			std::cout << "ERROR"; //Файл не удалось создать или открыть
		}
		if (flag2)
		{
			std::cout << "Такого студента не существует, повторите ввод фамилии и имени: "; //повторный ввод ФИ студента
			std::cin >> student1.name;
		}
		fin.close();
	}
	fin.open(way + delfile);
	fout.open(way + nameofgroup + attendance + choice + txt);
	if (fin.is_open() and fout.is_open())
	{
		std::string data = "";
		while (!fin.eof())
		{
			std::getline(fin, data);
			if (data == student1.name)
			{
				bool flag3 = 1;
				for (int i = 0; i < data.length(); i++)
				{											//процесс нахождения ФИ студента в файле
					if (flag3 and data[i] != 't')
					{
						fout << data[i];	//запись данных в файл с оценками
					}
					else
					{
						flag3 = 0;
					}

				}
				std::string choice2;
				std::cout << "Введите оценку: ";	//ввод оценки
				std::cin >> choice2;
				fout << "t" << choice2 << "n";	//запись данных в файл с оценками
			}
			else
			{
				fout << data << "n";	//запись данных в файл с оценками
			}
		}
	}
	else
	{
		std::cout << "ERROR"; //Файл не удалось создать или открыть
	}
	fin.close();
	fout.close();
	std::cout << "n";
	fin.open(way + nameofgroup + attendance + choice + txt);
	if (fin.is_open())
	{
		std::string data = "";
		while (!fin.eof())
		{
			std::getline(fin, data);
			std::cout << "ttt" << data << "n";	//вывод измененных данных на экран
		}
	}
	else
	{
		std::cout << "ERROR"; //Файл не удалось создать или открыть
	}
	fin.close();
}

Attendance

Функция Attendance реализует простановку посещаемости студентов с последующей записью в файл.

В ходе выполнения функции, пользователю предлагается ввести дату, за которую он хочет выставить посещаемость. После получения программой даты, происходит проверка на существование файла с посещаемостью на данную дату. Если файл существует, то происходит его запись в специализированный промежуточный файл, это происходит для реализации корректной и органичной записи в файл посещаемости, без потерь данных. Если файл не существует, то программа копирует данные из файла со списком группы в промежуточный файл. Следом, на экран выводится полный список группы с посещаемостью (если она есть). Пользователю предлагается ввести фамилию и имя студента, которому он хочет выставить посещаемость. Как только программа получает эти данные, происходит проверка на наличие данного студента в группе, если его нет, то пользователю предлагается ввести фамилию и имя повторно. После получения данных программой, происходит создание файла для посещаемости на данную дату (принцип нахождения пути файла и формирования его название – сложение строк). Следом, идет поиск данного студента в промежуточном файле. Принцип поиска и записи таков: если фамилия и имя не совпадает с введенными пользователем, то происходит запись этих данных в файл с оценками, если ФИ совпали, то пользователю предлагается ввести посещаемость студента, полученная строчка записывается в файл с посещаемостью. В конце работы функции, на экран выводится список группы с внесенными изменениями.

void Attendance()
{
	DataofStudent student1; //объявление переменной класса DataofStudent
	std::string way = "C:\journal\allgroup\", delfile = "delfile.txt", txt = ".txt", attendance = "\attendance", choice = "";//объявление переменных типа string
	bool flag = 0, flag2 = 1; //объявление переменной типа bool
	std::ofstream fout; //объявление пременной класса ofstream
	std::ifstream fin; //объявление переменной класса ifstream
	std::cout << "Введите дату за которую вы хотите проставить посещаемость: ";
	std::cin >> choice; //ввод даты
	fin.open(way + nameofgroup + attendance + choice + txt);
	if (fin.is_open())
	{
		flag = 1;	//проверка на наличие файла
	}
	fin.close();
	if (flag)
	{
		fin.open(way + nameofgroup + attendance + choice + txt);
		fout.open(way + delfile);
		if (fin.is_open() and fout.is_open())
		{
			std::string data = "";
			while (!fin.eof())	//запись данных файла в промежуточный файл
			{
				std::getline(fin, data);
				fout << data << "n";
			}
		}
		else
		{
			std::cout << "EROR";
		}
		fin.close();
		fout.close();
	}
	else
	{
		fin.open(way + nameofgroup + txt);
		fout.open(way + delfile);
		if (fin.is_open() and fout.is_open())
		{
			std::string data = "";
			while (!fin.eof())
			{						//запись списка группы в промежуточный файл
				std::getline(fin, data);
				fout << data << "n";
			}
		}
		else
		{
			std::cout << "EROR";
		}
		fin.close();
		fout.close();
	}
	fin.open(way + delfile);
	if (fin.is_open())
	{
		std::string data = "";
		while (!fin.eof())
		{
			std::getline(fin, data);
			std::cout << data << "n";	//ввывод списка группы на экран
		}
	}
	else
	{
		std::cout << "EROR";
	}
	fin.close();
	std::cout << "Введите фамилию и имя студента. которому вы хотите выставить посещаемость: " << std::endl;
	std::cin >> student1.name;	//ввод фамили и имени студента
	while (flag2)
	{
		fin.open(way + delfile);
		if (fin.is_open())
		{
			std::string data = "";
			while (!fin.eof())
			{
				std::getline(fin, data);
				if (data == student1.name)	//проверка на наличие данного студента в группе
				{
					flag2 = 0;
				}
			}
		}
		else
		{
			std::cout << "EROR";
		}
		if (flag2)
		{
			std::cout << "Такого студента не существует, повторите ввод фамилии и имени: ";	//повторный ввод ФИ студента
			std::cin >> student1.name;
		}
		fin.close();
	}
	fin.open(way + delfile);
	fout.open(way + nameofgroup + attendance + choice + txt);
	if (fin.is_open() and fout.is_open())
	{
		std::string data = "";
		while (!fin.eof())
		{
			std::getline(fin, data);
			if (data == student1.name)
			{
				bool flag3 = 1;
				for (int i = 0; i < data.length(); i++)
				{
					if (flag3 and data[i] != 't')
					{
						fout << data[i];	//процесс нахождения студента в файле
					}
					else
					{
						flag3 = 0;
					}

				}
				std::string choice2;
				std::cout << "Введите посещаемость: ";
				std::cin >> choice2; //ввод посещаемости
				fout << "t" << choice2 << "n";
			}
			else
			{
				fout << data << "n";
			}
		}
	}
	else
	{
		std::cout << "EROR";
	}
	fin.close();
	fout.close();
	std::cout << "n";
	fin.open(way + nameofgroup + attendance + choice + txt);
	if (fin.is_open())
	{
		std::string data = "";
		while (!fin.eof())
		{
			std::getline(fin, data); //вывод измененных данных на экран
			std::cout << "ttt" << data << "n";
		}
	}
	else
	{
		std::cout << "ERROR"; //Файл не удалось создать или открыть
	}
	fin.close();
}

Comment

Функция Comment реализует в программе написание комментария к дате.

В ходе выполнения функции, пользователю предлагается ввести дату, для которой он хочет написать комментарий. При получении программой даты, происходит открытие файла с режимом открытия ios_base::app (открыть файл для записи в конец файла). Наименование файла и путь его нахождения формируется, путем сложения строк. Пользователю предлагается ввести комментарий. Происходит запись данных в файл. После на экран выводятся изменённые данные файла.

void Comment()
{
	DataofStudent student1;//объявление переменной класса DataofStudent
	std::string way = "C:\journal\allgroup\", delfile = "delfile.txt", txt = ".txt", attendance = "\comment", choice = ""; //объявление переменнх типа string
	std::ofstream fout;//объявление переменной класса ofstream
	std::ifstream fin;//объявление переменной класса ifstream
	std::cout << "Введите дату для которой вы хотите оставить коментарий: ";
	std::cin >> choice; //ввод даты
	fout.open(way + nameofgroup + attendance + choice + txt, std::ios_base::app);
	if (fout.is_open())
	{
		std::string choice2;
		std::cout << "Введите коментарий: "; //ввод коментария
		std::cin >> choice2;
		fout << choice2 << "n";
	}
	else
	{
		std::cout << "ERROR"; //Файл не удалось создать или открыть
	}
	std::cout << "n";
	fout.close();
	fin.open(way + nameofgroup + attendance + choice + txt);
	if (fin.is_open())
	{
		std::string data = "";
		while (!fin.eof())
		{
			std::getline(fin, data);	//вывод изменненных данных на экран
			std::cout << "ttt" << data << "n";
		}
	}
	else
	{
		std::cout << "ERROR"; //Файл не удалось создать или открыть
	}
	fin.close();

}

Deadline

Функция Deadline реализует в программе создание dedlin’а и комментария к нему, с записью этих данных в файл.

В ходе выполнения функции, пользователю предлагается ввести дату, на которую он хочет установить deadline. При получении программой даты, происходит открытие файла с режимом открытия ios_base::app (открыть файл для записи в конец файла). Наименование файла и путь его нахождения формируется, путем сложения строк. Пользователю предлагается ввести комментарий. Происходит запись данных в файл. После на экран выводятся изменённые данные файла.

void Deadline()
{
	DataofStudent student1; //объявление переменной класса DataofStudent
	std::string way = "C:\journal\allgroup\", delfile = "delfile.txt", txt = ".txt", attendance = "\deadline", choice = ""; //объявление переменной типа string
	std::ofstream fout; //объявление переменной класса ofstream
	std::ifstream fin; //объявление переменной класса ifstream
	std::cout << "Введите дату на которую вы хотите установить deadline: ";
	std::cin >> choice; //ввод даты
	fout.open(way + nameofgroup + attendance + choice + txt, std::ios_base::app);
	if (fout.is_open())
	{
		std::string choice2;
		std::cout << "Введите коментарий к deadlin'у: "; //ввод коментария 
		std::cin >> choice2;
		fout << choice2 << "n";
	}
	else
	{
		std::cout << "ERROR"; //Файл не удалось создать или открыть
	}
	std::cout << "n";
	fout.close();
	fin.open(way + nameofgroup + attendance + choice + txt);
	if (fin.is_open())
	{
		std::string data = "";
		while (!fin.eof())
		{
			std::getline(fin, data);
			std::cout << "ttt" << data << "n"; //вывод измененных данных на экран
		}
	}
	else
	{
		std::cout << "ERROR"; //Файл не удалось создать или открыть
	}
	fin.close();
}

Main

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

В ходе выполнения программы, на экран выводится меню. Пользователю предлагается выбрать один из пунктов. При выборе пункта 1, вызывается функция Reg, а затем функция Authon; При выборе пункта 2, вызывается функция Authon; При выборе пункта 3 происходит выход из программы. После успешной авторизации вызывается функция GroupSelection. После выбора группы на экран выводится меню дальнейших действий. Пользователю предлагается выбрать один из пунктов. При выборе пункта 1 вызывается функция Grades; При выборе пункта 2 вызывается функция Attendance; При выборе пункта 3 вызывается функция Deadline; При выборе пункта 4 вызывается функция Comment; При выборе пункта 5 происходит выход из программы.

void main()
{
	std::string choice = ""; //объявление переменной типа string
	bool flag = 1; //объявление переменной типа bool
	setlocale(0, ""); //установка языкового стандарта для яязыка
	std::cout << "tttДобро пожаловать в электронный журналn"; //вывод меню на экран
	std::cout << "tttЕсли вы ходите зарегистрироваться введите 1ntttЕсли выхотите авторизоваться введите 2ntttЕсли вы хотите закрыть программу введите 3n";
	std::cin >> choice;//ввод символа, отвечающего за выбор пункта меню
	if (choice == "3")
	{
		return; //выход из программы
	}
	while (flag)
	{
		if (choice == "1")
		{
			flag = 0;
			Reg(); //регистрация
			Authon();//авторизация
		}
		else
		{
			if (choice == "2" and flag)
			{
				Authon(); //авторизация
				flag = 0;
			}
			else
			{
				std::cout << "Сделайте выбор повторно: ";
				std::cin >> choice; //повторное осуществленеи выбора пункта меню
			}
		}
	}
	GroupSelection(); //выбор группы
	std::cout << "ntttВыберете дальнейшее действие:n"; //вывод меню выбора дальнейших действий
	std::cout << "tttЕсли вы хотите поставить оценку студенту, введите 1ntttЕсли проставить посещаемость, введите 2ntttЕсли вы хотите установить дату конца дедлайна, введите 3ntttЕсли вы хотите написать коментарий, введите 4ntttЕсли вы хотите закрыть программу введите 5n";
	std::cin >> choice; // ввод символа, отвечающего за выбор пункта меню
	flag = 1;
	while (flag)
	{
		if (choice == "1")
		{
			flag = 0;
			Grades(); //простанока оценки
		}
		if (choice == "2")
		{
			flag = 0;
			Attendance(); //простановка посещаемости
		}
		if (choice == "3")
		{
			flag = 0;
			Deadline(); //установка deadlin'a
		}
		if (choice == "4")
		{
			flag = 0;
			Comment(); //написание комментария
		}
		if (choice == "5")
		{
			return; //выход из программы
		}
		if (choice != "1" and choice != "2" and choice != "3" and choice != "4" and choice != "5")
		{
			flag = 1;
			std::cout << "Повторите ввод: ";
			std::cin >> choice; //повторное осуществление выбора пункта меню
		}
	}
}

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

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

Тестирование и отладка программы

Для проведения корректного и полного тестирования следует поставить несколько тест кейсов, а именно.

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

Заключение

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

• Класс DataofTeature, хранящий в себе информацию о преподавателе.

• Класс DataofStudent, хранящий в себе информацию о студенте.

• Функция Reg, реализующая регистраци.

• Функцию Authon, реализующая авторизацию в программу.

• Функция GroupSelection, реализующая выбор группы.

• Функция Grades, реализующая простановку оценок.

• Функция Attendance, реализующая простановку посещаемости.

• Функция Comment, отвечающая за возможность написания комментария к дате.

• Функция Deadline, дающая возможность установить дэдлайн и написать к нему комментарий.

• Функция main, в которой реализовано основное взаимодействие пользователя с программой (меню и т.д.).

Весь код программы был написан в среде разработки Visual Studio 2022. Суммарный объем строк в тексте программы составляет 724.

Данная статья описывает основные конструкции в программировании и предназначена для тех, кто хочет в этом разобраться. Но статья не описывает все нюансы, потому что их слишком много. Если описывать их все, будет очень нудно и непонятно.

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

Двоичная система счисления

Числа в двоичной системе счисления состоят всего из двух знаков. Нуля и единицы. 00000001 – число один. 00000010 – число два. 00000100 – число 4. Как вы можете заметить, когда единица смещается влево, число увеличивается в два раза. Чтобы получилось число 3, необходимо написать 00000011. Таким образом можно составить все необходимые числа. В данном примере мы использовали двоичное число с восемью знаками, иначе говоря число восьмиразрядное. Чем больше у числа разрядов, тем большее оно может вместить значение. Например, восьмиразрядное число вмещает максимальное значение 255, если считать ноль, тогда 256, а в программировании ноль считается всегда. Если увеличить разряд на один, получится девятиразрядное число и его вместимость увеличится в два раза, то есть станет 512. Но так в программировании никогда не делается и обычно каждая следующая разрядность увеличивается вдвое. Один разряд, потом 2 разряда, потом 4 разряда, потом 8 разрядов, потом 16 разрядов, потом 32 разряда и далее.

Шестнадцатеричная система счисления

Всё аналогично двоичной, только вместо нулей и единиц участвуют цифры от 0 до 15. 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, A, B, C, D, E, F, где A – 10, B – 11, C – 12, D – 13, E – 14, F – 15.

Знак минус в программировании

Знак минус в двоичной системе счисления обозначается единицей в самом старшем разряде. Конечно же если число может быть минусовым (да, да, в программировании типы цифр бывают неминусовыми и включающим числа со знаком минус). 10000000 – число -1. Это не число -0, потому что минус нулей не бывает, то есть отрицательные числа смещаются влево на один. А вообще, в разных языках программирования может быть разное представление отрицательных чисел, но вам это знание вряд ли пригодится, поэтому пока что думайте, что всё так, как я объяснил.

Буквы и знаки

Буквы, знаки, смайлики и так далее обозначаются также числами. Буква А может быть числом 00000001 или любым другим, или даже комбинацией чисел в зависимости от кодировки символов. Кодировок много.

Типы данных

В программировании есть типы данных. Числовые, такие как 233, которые разобрали выше. Называются почти везде int, от слова integer. С плавающей запятой, такие как 198,76, называются почти везде float. У букв тип char, у строк тип String. Тип bool имеет два значения – истина (true) и ложь (false). У этого типа реализация в разных языках разная, но самая простая, когда ноль — значит ложь, а любое другое число истину. Нестандартные типы данных, такие как числа с фиксированной запятой, рассматривать не будем.

Применение

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

int value;

Это стандартное объявление примитивного типа.

Сначала пишем тип, потом имя переменной, то есть нашего числа. Всегда заканчиваем наше выражение, да и любое, точкой с запятой.
Теперь мы можем использовать переменную по её имени.

value = 112;

Здесь мы присвоили переменной значение. В отличии от математики в программировании = значит взять значение справа и присвоить переменной слева. = — это знак/оператор присвоения.

Можно объединить объявление и присвоение, то есть сразу инициализировать переменную.

int value0 = 113;
char a = ‘a’;
String line = “line”;

Буквы выделяются одинарными кавычками, строки выделяются двойными кавычками. Числа типа int не выделяются.

float b = 3.14f;

К числам с плавающей запятой одинарной точности в конце добавляется f.

double c = 1.2;

К числам с плавающей запятой двойной точности ничего не добавляется.

Операторы

С помощью операторов можно складывать, вычитать и делать много других операций с переменными. Операторами являются +, -, *, / и другие. Да даже; является оператором, говорящим, что выражение завершено.

После того как мы записали наше выражение, например сложения,

int a = 127;
int b = -12;
a + b;

получается значение. Но так как оно ни одной переменной не присваивается, оно исчезает. Чтобы присвоить значение переменной используется специальный оператор присвоения, который коротко описан выше.
Повторим ещё раз. Он берёт значение со своей правой стороны и присваивает его переменной в левой стороне. Это оператор =, и он не имеет ничего общего со знаком равно из математики.

int c = 12;
int d = 14;
int e = c + d;

Также у нас есть логические операторы, такие как < (меньше), > (больше), <= (меньше либо равно), == (равно), && (и), || (или) и другие.

Они сравнивают значения или выражения слева и справа, а после выдают истинность в виде типа bool, то есть true или false, и это значение также можно присвоить.

int f = 1;
int g = 4;
bool isTrue = g > f;

Оператор && (и) сравнивает два значения типа bool. Если слева true и справа true, тогда этот оператор возвращает значение true. В других случаях false.

Оператор || (или) возвращает истинность, если хоть одно значение истинно (true).

Комментарии

Комментарии нужны для того, чтобы не забыть, что мы напрограммировали или они информируют тех, кто будет пользоваться нашим кодом. Попросту заметки в коде.
Однострочные комментарии открываются знаками // и заканчиваются в конце строки.

//Комментарий.
int maxCount;

Вторая строка уже не комментарий.

Есть также многострочные комментарии и другие, которые я рассматривать не буду.

Операторы ветвления

Оператор ветвления if

if(a < 154) {
a = a + 1;
}

Если переменная a меньше 154, то есть выражение истинно, выполняет код в фигурных скобках, потом программа выполняется дальше. Код в фигурных скобках называется блоком кода. Он нужен для того, чтобы сказать программе, что этот код принадлежит оператору и именно его нужно выполнить.

Оператор ветвления if можно расширить.

if(isTrue && isFalse){
    b = b – 1;
    } else {
    b = b + 1
}

Если условие оператора истинно, выполняет первый блок кода, а если нет, тогда второй блок кода после else.

Оператор ветвления switch

switch(value){
    case 0:
        a = a + 1;
        break;
    case 1:
	a = a + b;
	break;
    case 6:
	b = b – a;
	b = b – 1;
	break;
    default:
	b = b + 1;
	break;
}

Этот оператор сравнивает значение в круглых скобках со значениями после case. Если значения совпадают, выполняет выражение или выражения после case, доходит до оператора break, после выходит из цикла и продолжает программу дальше. Если ни одно значение не совпадает, выполняет выражение после default. default можно и не писать.

switch(value){
    case 0:
	a = a + 1;
        break;
    case 1:
	a = a + b;
	break;
}

Циклы

Цикл for

Циклы выполняют блок кода по кругу, пока определённое действие их не остановит.

for(int i = 32; i >=0; i = i – 1){
    a = b + c + d;
}

За круглыми скобками в порядке очереди идут инициализация переменной, которая будет счётчиком, условие, при котором цикл выполняется вновь и вновь при истинности условия, выражение, которое выполняется после того, как выполнится блок кода цикла. То есть этот цикл будет выполняться снова и снова, пока переменная i больше либо равна нулю, и, начиная со второго выполнения цикла, значение переменной i будет уменьшаться на единицу. После того, как условие станет ложным, программа начнёт выполняться дальше.

Цикл while

while(i > 3){
    i = i – 2;
}

Цикл while выполняется до тех пор, пока условие в круглых скобках истинно.

Если условие будет ложным, но нам необходимо чтобы цикл выполнился один раз, тогда используем следующую конструкцию

do{
    i = i – 2;
} while(false);

Область видимости

int a = 4;
{ 
    int b = 0;
    b = a + b;
}

Также фигурными скобками определяется область видимости. Все переменные, объявленные внутри фигурных скобок, невидимы во внешней области, но внешняя область видна внутри фигурных скобок. Поэтому мы можем использовать внутри фигурных скобок внешние переменные, но не можем во внешней области использовать переменные, объявленные внутри внутренней области.

Ключевые слова

В языках программирования есть наборы ключевых слов, в каждом языке свой набор. Этими словами ничего называть нельзя. Ни переменные, ни методы/функции, ничего подобного. Слово while ключевое и другие подобные слова также ключевые.

Массивы

Массивы – это набор значений одного типа. Они удобны, когда нам нужно что-то перечислить.

int[] items = new int[7];

Так выглядит обычное объявление массива. Сначала указываем нужный тип. Потом ставим квадратные скобки, этим говорим языку программирования, что объявляем массив. Далее вписываем его имя. После знака присвоения вписываем выражение инициализации, то есть создания массива. Там мы видим новый оператор new, который используется при создании массива. Если сказать проще, мы создаём семь переменных типа int и присваиваем их нашему массиву под именем items.

Мы создали массив с семью элементами, но обращаться к первому начинаем с 0. Поэтому последний элемент будет под индексом 6. Не забывайте об этом смещении.

Обращение к элементу массива и присвоение его переменной выглядит так

int a = items[0];

Вход в программу

Мы рассмотрели все основные моменты, чтобы хоть что-то понимать, поэтому теперь перейдём к написанию простой программы.

Началом программы является метод main. Любой метод подобен блоку кода, но с именем. Его можно вызвать из другой части программы по имени, но метод main нельзя, потому что он вход в программу, а вход должен быть один. Метод main срабатывает только при запуске.

int addAndMultiplyByTwo(int a, int b){
    return (a + b) * 2;
}

А это простейший метод, который сейчас разберём. В круглых скобках указываются входные параметры. Можете их представить, как уже объявленные переменные в блоке кода, которым мы можем присвоить значения извне. Внутри фигурных скобок первый оператор, который мы видим, это return. Он берёт значение справа, которое получается из выражения, и передаёт его вовне. Тип передаваемого вовне значения должен быть таким же, как указанный перед именем метода, то есть int.

int g = 6;
int z = addAndMultiplyByTwo(7, g);

Так метод вызывается и результат его выполнения передаётся в переменную z.

class HelloWorld {
    public static void main(String args []) {
        System.out.println("Hello World");
    }
}

В этом примере сначала создаётся класс HelloWorld. Пока что думайте, что класс – это файл, в который мы записываем текст программы.

Далее идёт объявление метода main. По словам слева от его имени мы можем понять, что метод публичный (слово public), то есть мы можем вызвать его не только из этого класса, но и извне. По слову static мы можем понять, что метод статичный, то есть можно его вызвать без разных манипуляций, которые мы рассмотрим позже. Слово void говорит, что метод ничего не возвращает. В круглых скобках есть аргумент args[]. Этот аргумент является пустым массивом строк. Можно добавить забитый чем-то массив строк, но нам это не нужно, потому что использовать его мы не будем, а программа запустится и так.

Следующим мы видим вызов метода println, в параметр которого помещена строка Hello World. Перед ним мы видим перечисление через точки System.out. Если кратко, слово System означает, что метод println находится в классе System, а слово out – это выходной поток PrintStream, который нужен, чтобы выдать информацию вовне. В этом примере вовне — это консоль. Выходной поток out мы рассматривать не будем. Разбор потоков может вылиться в отдельную статью. Нам важно только знать, что out (объект класса PrintStream) находится в классе System, а метод println находится в объекте out. Все эти перечисления через точку просто указывают путь языку программированию к методу println, чтобы он знал откуда его вызывать.

Этот метод выводит строку Hello World в консоль и переводит курсор на новую строку. На этом программа заканчивается.

Компиляция и выполнение

Синтаксис простой программы мы рассмотрели, но не запустили её. Этим мы сейчас и займёмся.
Для начала скачайте JDK и установите его. Потом в переменных средах вашей операционной системы пропишите в переменной Path путь к папке bin вашего установленного JDK. Это нужно, чтобы операционная система могла найти из консоли программы JDK для компиляции и запуска. Теперь поместите текст программы в текстовый файл с именем HelloWorld. С именем HelloWorld, потому что имя файла и класса должны совпадать. Сохраните и измените расширение файла на java. Перейдите в консоли в папку с файлом и введите javac HelloWorld.java. Программа скомпилируется и поместится в файл HelloWorld.class. Чтобы запустить её напишите java HelloWorld. В выводе вы увидите Hello World. Что мы и хотели.

Импорт

Чтобы использовать другие классы и методы из стандартной библиотеки используем слово import.

import java.util.Random;

После слова import идёт название пакета java.util. Он назван так из-за назначения и, собственно, из-за папок java и util, в которых находится класс Random. Путь javautilRandom.class
Вместо java.util.Random можно вписать любой необходимый нам класс.

Классы и объекты. Статические и динамические реализации

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

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

class MyClass {
    public static void main(String [] args){
	
        AnotherClass object0 = new AnotherClass();
	
        System.out.println(object0.a);
        System.out.println(object0.addition(8, 10));
    }
}

public class AnotherClass{
    int a  = 9;
	
    int addition(int b, int c){
        return b + c;
    }
}

Разберём их. Начнём с класса AnotherClass. Перед его именем мы видим слово public, которое говорит, что класс публичный и его могут использовать другие классы. В нём мы создаём переменную a со значением 9 и метод addition. Можно сказать, что класс AnotherClass – это новый тип.

В классе MyClass мы создаём объект object0 класса AnotherClass. Это очень похоже на создание обычной переменной и также используется ключевое слово new, как при создании массива. Оператор new говорит языку программирования, что нужно создать копию этого класса в оперативной памяти. Мы можем создать множество копий и забить ими всю память. Далее мы передаём переменную a этого объекта в метод println. Dызываем динамические метод addition в параметре метода println. Метод addition вернёт результат, а метод println выведет его.

Динамический метод отличается от статического тем, что его можно вызвать только из объекта, загруженного в память. То есть для начала нужно создать объект. Статический метод можно вызывать напрямую из класса, то есть просто написав имя класса, поставить точку и через неё вызвать метод. Но у статических методов есть ограничения. Внутри их тела невозможно обращаться к динамическим переменным объекта класса, в котором находятся эти методы. Так как статический метод не загружается в оперативную память, в нём нельзя использовать переменные объекта, загруженные в неё.
Чтобы создать статический метод, перед его именем нужно написать static.

Конструкторы

class MyClass2 {
    public static void main(String [] args){
	
        AnotherClass2 object0 = new AnotherClass2();
        AnotherClass2 object1 = new AnotherClass2(6);
	
        System.out.println(object0.a);
        System.out.println(object0.a);
    }
}

public class AnotherClass2{
    public AnotherClass2(){
        a = 7;
    }

    public AnotherClass2(int x){
        a = x;
    }

    int a;
}

В этих классах почти всё идентично предыдущим, но создаётся два объекта класса AnotherClass2. object0 и object1. Но создаются они по-разному.

Разберём класс AnotherClass2. В нём появился новый механизм, который называется конструктор. Конструкторов в классе может быть несколько, начинаются они со слова public, а далее идёт имя класса. В круглых скобках перечисляются параметры, а в теле конструктора описывается инициализация объекта класса. Конструкторы схожи с методами.

Перейдём к разбору конструкторов в классе MyClass2. В этом классе при создании объектов класса AnotherClass2 мы можем указать параметры в круглых скобках. Язык программирования выберет подходящий под параметры конструктор и проинициализирует объект подходящим образом. Так при создании объектов мы можем создать его разновидность нужную нам.

post scriptum

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

BB 11 01 B9 0D 00 B4 0E 8A 07 43 CD 10 E2 F9 CD 20 48 65 6C 6C 6F 2C 20 57 6F 72 6C 64 21

#include <iostream>

int main()
{
    std::cout << "Hello, World! n";
}

Научитесь: Профессия Разработчик на C++ с нуля
Узнать больше