Как составить программный код

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

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

Использовать будем си-подобный синтаксис, то есть подобный языку си, но не будем вникать в заголовочные файлы, указатели и другие особенности относительно низкоуровневых языков, перейдём на синтаксис более высокоуровневых языков, которые сделают рутинную работу за нас. А конкретно, будем использовать синтаксис языка 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

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

В этой главе мы напишем первую программу на 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++ и посмотрим, как происходит их компиляция.

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

Создаём каталог проекта

Перейдите в каталог пользователя, и создайте каталог, в котором вы будете размещать свои проекты. Его можно назвать, например, “lw1” (laboratory work 1)

В Visual Studio Code откройте этот каталог. Для этого используйте меню “File”>”Open Folder…”.

Теперь вы можете добавить новый файл в каталог прямо из Visual Studio Code. Попробуйте, это так просто!

Простейшая программа

Откройте редактор, создайте файл hello.cpp и перепишите следующий текст:

Это — минимальная программа на языке C++. Она выводит в терминал строку “Hello, world!” и завершается. Она состоит из:

• директива #include <iostream> подключит библиотеку потоков ввода-вывода, в том числе станут доступны поток вывода std::cout и манипулятор std::endl.
• функция main служит точкой входа в программу в тот момент, когда операционная система запускает программу
• в функции сейчас находится ровно одна инструкция, которая передаёт строку в поток вывода cout и затем передаёт туда же манипулятор endl (сокращение от end line), чтобы добавить перенос строки и завершить операцию вывода cout

Сохраните файл — это можно сделать в меню “File” либо горячей клавишей Ctrl+S:

Затем откройте терминал. В Visual Studio Code терминал можно открыть в меню “Вид”>”Интегрированный терминал” либо сочетанием клавиш “CTRL + `”

Введите в терминале команду dir. Команда выведет список файлов, и среди этих файлов должен быть файл hello.cpp.

Введите команду g++ --version. Программа g++ — это компилятор C++ из состава GCC (GNU Compiler Collections). Передав ей флаг --version, вы заставите программу вывести свою версию и завершиться. Ожидается, что у вас будет g++ 7.0 или выше:

C:CodeCppProjects>g++ --version
g++ (GCC) 7.2.0
Copyright (C) 2017 Free Software Foundation, Inc.
This is free software; see the source for copying conditions.  There is NO
warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

Введите команду g++ hello.cpp -o hello. Эта команда компилирует файл hello.cpp в исполняемую программу называет исполняемый файл hello.exe на платформе Windows либо hello на Linux и MacOSX. Команда не должна выводить чего-либо, она должна просто успешно завершиться.

Теперь вы можете запустить исполняемую программу hello.exe, набрав в терминале команду hello.

C:CodeCppProjects>hello
Hello, world!

Задание cpp1.1

Убедитесь, что у вас есть файл hello.cpp, в котором записана работоспособная программа “Hello, World”. Доработайте программу, чтобы вместо “Hello, World” она выводила “Hello, Name”, где Name – ваше имя в английской транскрипции.

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

Теперь попробуем составить неправильную программу. Например, уберём символ ; в конце единственной инструкции:

Запустите компиляцию снова. Вы увидите ошибку компиляции, примерно такую:

C:CodeCppProjectsother>hello
Hello, world!

C:CodeCppProjectsother>g++ hello.cpp -o hello
hello.cpp: In function 'int main()':
hello.cpp:6:1: error: expected ';' before '}' token
 }
 ^

Компилятор достаточно умён, чтобы показать вам точное место ошибки и способ её исправления! Именно поэтому сообщения от компиляторов C/C++ следует внимательно читать.

Теперь попробуем внедрить другую ошибку: точку с запятой вернём на место, а в названии cout перепутаем две буквы: “cuot”

Запустите компилятор и прочитайте сообщение. Оно должно быть таким:

C:CodeCppProjectsother>g++ hello.cpp -o hello
hello.cpp: In function 'int main()':
hello.cpp:5:10: error: 'cuot' is not a member of 'std'
     std::cuot << "Hello, world!" << std::endl;
          ^~~~
hello.cpp:5:10: note: suggested alternative: 'clog'
     std::cuot << "Hello, world!" << std::endl;
          ^~~~
          clog

Компилятор снова показал себя с лучшей стороны: он догадался, что программист опечатался, и предложил свой вариант замены. К сожалению, вариант не самый удачный: компилятор предложил clog вместо cout. Тем не менее, во многих случаях компилятор угадывает правильно.

Задание cpp1.2

• Попробуйте самостоятельно найти такую опечатку в слове cout, чтобы компилятор правильно предложил способ исправления опечатки.
• Этот вариант программы сохраните в файле hello_err.cpp, чтобы затем показать преподавателю.

Вывод в стиле языка C

Вывод в cout, которым мы воспользовались, относится к языку C++. Есть и другой способ: C++ позволяет использовать возможности языка C, в том числе функции ввода-вывода в стиле языка C.

Мы воспользуемся функцией std::puts. Для доступа к ней надо подключить <cstdio>. Теперь программа будет выглядеть так:

Выполните в терминале команду del hello.exe для удаления старого исполняемого файла, затем g++ hello.cpp -o hello для компиляции и запустите программу hello.exe. Вы должны получить тот же результат, что и раньше:

C:CodeCppProjectsother>hello
Hello, world!

Ввод-вывод

Теперь напишем программу, которая читает два числа из стандартного ввода и пишет их обратно в стандартный вывод. Эта программа будет использовать функции языка C: std::scanf и std::printf.

Создайте файл ab.cpp и напечатайте в нём следующий код:

Скомпилируйте код командой g++ ab.cpp -o ab. Запустите, и введите

• два целых числа: 12 88
• одно целое число и одно число с плавающей точкой: 12 88.7
• одно целое число и одну букву f: 12 f
• только букву f: f
• ничего не вводить, сразу нажать “Ctrl+Z” на Windows или “Ctrl+D” на остальных платформах, что означает “конец ввода”

Если что-то пошло неправильно, вы можете нажать в терминале Ctrl+C для завершения программы.

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

// Подключаем заголовок cstdio из стандартной библиотеки
#include <cstdio>

// Определяем функцию main, возвращающую целочисленный код завершения.
int main()
{
    // Объявляем переменные a и b, инициализируем их нулями.
    int a = 0;
    int b = 0;

    // Считываем из стандартного ввода данные в определённом формате: "%d %d"
    //  "%d" означает "считать целое число и положить результат по переданному адресу",
    //  " " означает "считать любое количество пробелов"
    //  адреса для записи считанных значений передаются в дополнительных аргументах, начиная со 2-го
    // Документация: https://www.opennet.ru/man.shtml?topic=scanf&category=3&russian=0
    std::scanf("%d %d", &a, &b);

    // Записываем данные в определённом формате: "%d %dn"
    //  "n" кодирует символ переноса строки
    // Документация: https://www.opennet.ru/man.shtml?topic=printf&category=3&russian=0
    std::printf("%d %dn", a, b);
}

Теперь доработаем программу

Задание cpp1.3

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

Решение линейного уравнения

Рассмотрим линейное уравнение ax + b = 0 — оно также называется уравнением прямой. Мы напишем программу, способную решать такие уравнения. Но прежде чем приступить к кодированию, мы составим план действий с помощью комментариев:

#include <cstdio>

int main()
{
	// 1. prompt user to enter coefficients

	// 2. read coefficients for equation `ax + b = 0`
    
	// 3. solve equation `ax + b = 0`
	// solution: `x = -b / a`
}

Первый шаг мы реализуем с помощью puts. Второй — с помощью scanf и объявления переменных a, b. Третий шаг – с помощью printf. Создайте файл linear_equation.cpp.

Перепечатайте в него следующий код:

Скомпилируйте программу и запустите её. Попробуйте ввести две пары коэффициентов:

• -10 и 2
• 2 и -10
• 0 и 2
• 0 и 0

Везде ли программа решила задачу правильно?

Числа с плавающей точкой

Конечно же, решить уравнение в целых числах получится не всегда. Но в C++ есть поддержка чисел с плавающей точкой:

• тип данных называется float
• ему соответствует формат %f для scanf и printf

Перепишите программу следующим образом:

Попробуйте снова ввести две пары коэффициентов:

• -10 и 2
• 2 и -10
• 0 и 2
• 0 и 0

Как вы думаете, что получилось в последних двух случаях? Почему такое происходит?

Задание cpp1.4

Создайте файл square_equation.cpp и напишите программу, которая читает три коэффициента уравнения ax^2+bx+c=0 и вычисляет корни уравнения.

• Программа должна использовать числа с плавающей точкой.
• Вам пригодится функция std::sqrt, помогающая извлечь квадратный корень; в документации к ней сказано, какой заголовочный файл требуется подключить через #include <...>.