Структуры

Содержание:

Оператор безусловного перехода goto

Общая форма записи

goto Метка;. . .Метка : Операция;

gotoМеткойМеткаМеткиОперацииМеткаgotoМетокПример на Си

123456789101112

#define _CRT_SECURE_NO_WARNINGS // для возможности использования scanf#include <stdio.h>int main() { int k = 5;M1: if (k < 0) // если k<0, goto M2; // переходим на метку M2 (выходим из программы) printf(«%d «, k); // выводим значение k k—; // уменьшаем k на 1 goto M1; // переходим на метку M1 (повторяем операции выше)M2: getchar(); return 0;}

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

Язык Си

Что такое структура в языке Си

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

дата издания;
номер выпуска;
название;
стоимость.

Для решения этой задачи можно было бы применить массивы.

Объявляем массив с датами int date, номерами int number, названиями char title, стоимостью int price.

Обращаясь по индексу, мы получаем требуемую информацию. Вывод информации о произведении под номером 3 выглядит так: cout

Структура упрощает запись, описывается следующим образом:

struct book {

int date;

int number;

char title;

int price;

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

Структуры и функции

#include <stdio.h>
#include <math.h>
 
struct circle { int x, y; float dia; char color10; };
struct circle new_circle();
void cross (struct circle);
 
main () {
	struct circle a;
 
	a = new_circle();
	cross(a);
}	
 
struct circle new_circle() {
	struct circle new;
 
	printf("Координаты: "); scanf("%d%d", &new.x, &new.y);
	printf("Диаметр: "); scanf("%f", &new.dia); 
	printf("Цвет: "); scanf("%s", new.color);//gets(new.color);
 
	return new;
}
 
void cross (struct circle c) {
	double hyp;
 
	hyp = sqrt((double) c.x * c.x + (double) c.y * c.y);
	printf("Расстояние от центра круга до начала координат: %.2lf\n", hyp);
	if (hyp <= c.dia  2) puts("Круг пересекает начало координат");
	else puts("Круг не содержит точки начала коорднат");
}

Примечание. При компиляции программы в GNU/Linux команда выглядит так: . Это связано с использованием библиотеки с математическими функциями.

Объявляется структура circle как глобальный тип данных. Таким образом любая, а не только , функция может создавать переменные этого типа.
Функция возвращает структуру, а функция принимает структуру по значению. Следует отметить, что можно создавать функции, которые как принимают (возможно, несколько структур) так и возвращают структуру.
В функции создается переменная new типа struct circle, поля которой заполняются пользователем. Функция возвращает значение переменной new в функцию , где это значение присваивается переменной a, которая также принадлежит типу sctruct circle.
Функция определяет, пересекает ли круг начало координат. В ее теле вычисляется расстояние от центра круга до начала координат. Это расстояние является гипотенузой прямоугольного треугольника, длина катетов которого равна значениям x и у. Далее, если гипотенуза меньше радиуса, то круг пересекает начало координат, т.е. точку (0, 0).
В функции при вызове данные, содержащиеся в переменной a, копируются и присваиваются переменной c.

Инициализация переменных

При объявлении переменной мы можем присвоить ей значение в этот же момент. Это называется инициализацией переменной.

C++ поддерживает два основных способа инициализации переменных:

Способ №1: Копирующая инициализация (или «инициализация копированием») с помощью знака равенства :

int nValue = 5; // копирующая инициализация

1	intnValue=5;// копирующая инициализация

Способ №2: Прямая инициализация с помощью круглых скобок :

int nValue(5); // прямая инициализация

1	intnValue(5);// прямая инициализация

Прямая инициализация лучше работает с одними типами данных, копирующая инициализация — с другими.

Где объявлять переменные?

Более старые версии компиляторов языка Си вынуждали пользователей объявлять все переменные в верхней части функции:

#include <iostream>

int main()
{
// Все переменные в самом верху функции
int x;
int y;

// а затем уже весь остальной код
std::cout << «Enter a number: «;
std::cin >> x;

std::cout << «Enter another number: «;
std::cin >> y;

std::cout << «The sum is: » << x + y << std::endl;
return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

#include <iostream>

intmain()

{

// Все переменные в самом верху функции

intx;

inty;

// а затем уже весь остальной код

std::cout<<«Enter a number: «;

std::cin>>x;

std::cout<<«Enter another number: «;

std::cin>>y;

std::cout<<«The sum is: «<<x+y<<std::endl;

return;

}

Сейчас это уже неактуально. Современные компиляторы не требуют, чтобы все переменные обязательно были объявлены в самом верху функции. В языке С++ приоритетным является объявление (а также инициализация) переменных как можно ближе к их первому использованию:

#include <iostream>

int main()
{
std::cout << «Enter a number: «;
int x; // мы используем x в следующей строке, поэтому объявляем эту переменную здесь (как можно ближе к её первому использованию)
std::cin >> x; // первое использование переменной x

std::cout << «Enter another number: «;
int y; // переменная y понадобилась нам только здесь, поэтому здесь её и объявляем
std::cin >> y; // первое использование переменной y

std::cout << «The sum is: » << x + y << std::endl;
return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

#include <iostream>

intmain()

{

std::cout<<«Enter a number: «;

intx;// мы используем x в следующей строке, поэтому объявляем эту переменную здесь (как можно ближе к её первому использованию)

std::cin>>x;// первое использование переменной x

std::cout<<«Enter another number: «;

inty;// переменная y понадобилась нам только здесь, поэтому здесь её и объявляем

std::cin>>y;// первое использование переменной y

std::cout<<«The sum is: «<<x+y<<std::endl;

return;

}

Такой стиль написания кода имеет несколько преимуществ.

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

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

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

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

Правило: Объявляйте переменные как можно ближе к их первому использованию.

Примечания

Мейер Б. Почувствуй класс. Учимся программировать хорошо с объектами и контрактами. — Пер. с англ. — М.: Национальный открытый университет ИНТУИТ: БИНОМ. Лаборатория знаний, 2011. — 775с. — С. 208. — ISBN 978-5-9963-0573-5
↑
Лингер Р., Миллс Х., Уитт Б. Теория и практика структурного программирования. — Пер. с англ. — М.: Мир, 1982. — 406с. — С. 7.
↑
↑ Дейкстра Э. Заметки по структурному программированию. // Дал У., Дейкстра Э., Хоор К. Структурное программирование. — М.: Мир, 1975. — С. 7–97.
↑
Бутаков Е. А. Методы создания качественного программного обеспечения ЭВМ. — М.: Энергоатомиздат, 1984. — 232с. — С. 114.
↑ Мейер Б. Почувствуй класс. Учимся программировать хорошо с объектами и контрактами. — Пер. с англ. — М.: Национальный открытый университет ИНТУИТ: БИНОМ. Лаборатория знаний, 2011. — 775с. — С. 209. — ISBN 978-5-9963-0573-5
↑ Wirth N. Program Development by Stepwise Refinement // Communications of the ACM, Volume 14, No. 4, April 1971, pp. 221—227. — Association for Computing Machinery, Inc.
Гласс Р. Руководство по надежному программированию. — М.: Финансы и статистика, 1982. — 256с. — С. 84.
Хьюз Дж., Мичтом Дж. Структурный подход к программированию. — М.: Мир, 1980. — 278c. — С. 29—71. (См. «Глава 2. Нисходящая разработка. Проектирование программы» и «Глава 3. Нисходящая разработка. Планирование и реализация»).
Вирт Н. Систематическое программирование. Введение. — М.: Мир, 1977. — 184с. — С. 139—168. (См. «Глава 15. Пошаговая разработка программ»).
Гласс Р. Руководство по надежному программированию. — М.: Финансы и статистика, 1982. — 256с. — С. 83-87. (См. Раздел «3.3.1. Программирование сверху вниз и снизу вверх»).
Лингер Р., Миллс Х., Уитт Б. Теория и практика структурного программирования. — М.: Мир, 1982. — 406с. — С. 324—327. (См. Раздел «7.3.3. Структурное программирование по нисходящему принципу» и «Раздел 7.3.4. Программирование с использованием принципа пошаговой реорганизации»).
Дал У., Дейкстра Э., Хоор К. Структурное программирование. — М.: Мир, 1975. — 247c.
Хоор К. Предисловие. // Дал У., Дейкстра Э., Хоор К. — М.: Мир, 1975. — 247c. — С. 6.
Йодан Э. Структурное проектирование и конструирование программ. — Пер. с англ. — М.: Мир, 1979. — 415с. — С. 174.
Йодан Э. Структурное проектирование и конструирование программ. — Пер. с англ. — М.: Мир, 1979. — 415с. — С. 174, 175.
Йодан Э. Структурное проектирование и конструирование программ. — Пер. с англ. — М.: Мир, 1979. — 415с. — С. 175.
Вельбицкий И. В., Ходаковский В. Н., Шолмов Л. И. Технологический комплекс производства программ на машинах ЕС ЭВМ и БЭСМ-6. — М.: Статистика, 1980. — 263с. — С. 5.
Стогний А. А. Предисловие. // Вельбицкий И. В., Ходаковский В. Н., Шолмов Л. И. Технологический комплекс производства программ на машинах ЕС ЭВМ и БЭСМ-6. — М.: Статистика, 1980. — 263с. — С. 3.
↑ Межгосударственный стандарт ГОСТ 19.005-85. Единая система программной документации. Р-схемы алгоритмов и программ. Обозначения условные графические и правила выполнения. Unified system for program documentation. R-charts. Graphical chart symbols and conventions for charting. 1985.
Знакомьтесь, Р-технология // НТР: проблемы и решения. — 1987, № 13, 7-20 июля. — С. 4, 5.
↑ (недоступная ссылка)

uniform-инициализация

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

В попытке обеспечить единый механизм инициализации, который будет работать со всеми типами данных, в C++11 добавили новый способ инициализации, который называется uniform-инициализация:

int value{5};

1	intvalue{5};

Инициализация переменной с пустыми фигурными скобками указывает на инициализацию по умолчанию (переменной присваивается ):

int value{}; // инициализация переменной по умолчанию значением 0 (ноль)

1	intvalue{};// инициализация переменной по умолчанию значением 0 (ноль)

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

int value{4.5}; // ошибка: целочисленная переменная не может содержать нецелочисленные значения

1	intvalue{4.5};// ошибка: целочисленная переменная не может содержать нецелочисленные значения

Правило: Используйте uniform-инициализацию.

Подпрограмма

Основная статья: Подпрограмма

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

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

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

Метод «сверху вниз»

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

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

После того, как программист убедится, что подпрограммы вызываются в правильной последовательности (то есть общая структура программы верна), подпрограммы-заглушки последовательно заменяются на реально работающие, причём разработка каждой подпрограммы ведётся тем же методом, что и основной программы. Разработка заканчивается тогда, когда не останется ни одной заглушки.

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

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

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

Объявление нескольких переменных

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

int a, b;

inta,b;

int a;
int b;

1 2	inta; intb;

Кроме того, вы даже можете инициализировать несколько переменных в одной строке:

int a = 5, b = 6;
int c(7), d(8);
int e{9}, f{10};

1
2
3

inta=5,b=6;

intc(7),d(8);

inte{9},f{10};

Есть три ошибки, которые совершают новички при объявлении нескольких переменных в одном стейтменте:

Ошибка №1: Указание каждой переменной одного и того же типа данных при инициализации нескольких переменных в одном стейтменте. Это не критичная ошибка, так как компилятор легко её обнаружит и сообщит вам об этом:

int a, int b; // неправильно (ошибка компиляции)

int a, b; // правильно

1
2
3

inta,intb;// неправильно (ошибка компиляции)

inta,b;// правильно

Ошибка №2: Использование разных типов данных в одном стейтменте. Переменные разных типов должны быть объявлены в разных стейтментах. Эту ошибку компилятор также легко обнаружит:

int a, double b; // неправильно (ошибка компиляции)

int a; double b; // правильно (но не рекомендуется)

// Правильно и рекомендуется (+ читабельнее)
int a;
double b;

1
2
3
4
5
6
7

inta,doubleb;// неправильно (ошибка компиляции)

inta;doubleb;// правильно (но не рекомендуется)

// Правильно и рекомендуется (+ читабельнее)

inta;

doubleb;

Ошибка №3: Инициализация двух переменных с помощью одной операции:

int a, b = 5; // неправильно (переменная a остаётся неинициализированной)

int a = 5, b = 5; // правильно

1
2
3

inta,b=5;// неправильно (переменная a остаётся неинициализированной)

inta=5,b=5;// правильно

Хороший способ запомнить эту ошибку и не допускать в будущем — использовать прямую или uniform-инициализацию:

int a, b(5);
int c, d{5};

1 2	inta,b(5); intc,d{5};

Этот вариант наглядно показывает, что значение присваивается только переменным и .

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

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

Классы

Класс и структура похожи по между собой, но отличаются некоторыми нюансами. Что это такое? Это абстракция, описывающая методы еще не существующего объекта. После создания объект или, как он называется по-другому, экземпляр класса имеет конкретные свойства. Методы могут использоваться внутри, снаружи или при наследовании.

Класс объявляется так:

class /*class name*/

{

private:

/* спецификатор доступа private обозначает, что управление методами возможно только внутри класса*/

public:

/* делает свойства доступными для других частей кода */

protected:

/* наследуемые классы получают возможность использовать эти свойства */

Массивы

Прежде чем говорить о структуре в Си, нужно описать массив.

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

You will be interested:How dangerous is the new coronavirus?

Обычный массив в Си записывается так: int a = {1, 2, 3, 4}.

Видим, что a — имя, int — тип данных, внутри фигурных скобок { } находятся значения, между квадратными скобками указывается длина, то есть количество элементов. Количество элементов является статическим, равняется 4. Это означает, что если в этом примере пользователь добавит пятое значение, компилятор выдаст ошибку. Если изначально не известно количество, они могут быть добавлены позже, но в квадратных скобках не ставится значение.

Двумерный объявляется похожим образом. Например, массив, который содержит 5 элементов-массивов, при этом каждый содержит по 3 элемента объявляется так: int a.По аналогии с одномерным добавлять ничего нельзя, чтобы не получить ошибку компилирования.

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

Структуры

Последнее обновление: 09.10.2017

Ранее для определения классов мы использовали ключевое слово class. Однако C++ предоставляет еще один способ
для определения пользовательских типов, который заключается в использовании структур. Данный способ был унаследован языком С++ еще от языка Си.

Структура в языке C++ представляет собой производный тип данных, который представляет какую-то определенную сущность, также как и класс.
Нередко структуры применителько к С++ также называют классами. И в реальности различия между ними не такие большие.

Для определения структуры применяется ключевое слово struct, а сам формат определения выглядит следующим образом:

struct имя_структуры
{
	компоненты_структуры
};

Имя_структуры представляет произвольный идентификатор, к которому применяются те же правила, что и при наименовании переменных.

После имени структуры в фигурных скобках помещаются Компоненты_структуры, которые представляют набор описаний объектов и функций, которые составляют структуру.

Например, определим простейшую структуру:

#include <iostream>
#include <string>

struct person
{
	int age;
	std::string name;
};

int main()
{
	person tom;
	tom.name = "Tom";
	tom.age = 34;
	std::cout << "Name: " << tom.name << "\tAge: " << tom.age << std::endl;
	return 0;
}

Здесь определена структура , которая имеет два элемента: (представляет тип int) и
(представляет тип string).

После определения структуры мы можем ее использовать. Для начала мы можем определить объект структуры — по сути обычную переменную, которая будет
представлять выше созданный тип. Также после создания переменной структуры можно обращаться к ее элементам — получать их значения или, наоборот, присваивать им новые значения.
Для обращения к элементам структуры используется операция «точка»:

имя_переменной_структуры.имя_элемента

По сути структура похожа на класс, то есть с помощью структур также можно определять сущности для использования в программе. В то же время
все члены структуры, для которых не используется спецификатор доступа (public, private), по умолчанию являются открытыми (public).
Тогда как в классе все его члены, для которых не указан спецификатор доступа, являются закрытыми (private).

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

person tom = { 34, "Tom" };

Инициализация структур аналогична инициализации массивов: в фигурных скобках передаются значения для элементов структуры по порядку. Так как
в структуре person первым определено свойство, которое представляет тип int — число, то в фигурных скобках вначале идет число.
И так далее для всех элементов структуры по порядку.

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

class Person
{
public:
	Person(std::string n, int a)
	{
		name = n; age = a;
	}
	void move()
	{
		std::cout << name << " is moving" << std::endl;
	}
	void setAge(int a)
	{
		if (a > 0 && a < 100) age = a;
	}
	std::string getName()
	{
		return name;
	}
	int getAge()
	{
		return age;
	}
private:
	std::string name;
	int age;

};

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

#include <iostream>
#include <string>

struct user
{
public:
	user(std::string n, int a)
	{
		name = n; age = a;
	}
	void move()
	{
		std::cout << name << " is moving" << std::endl;
	}
	void setAge(int a)
	{
		if (a > 0 && a < 100) age = a;
	}
	std::string getName()
	{
		return name;
	}
	int getAge()
	{
		return age;
	}
private:
	std::string name;
	int age;

};

int main()
{
	user tom("Tom", 22);
	std::cout << "Name: " << tom.getName() << "\tAge: " << tom.getAge() << std::endl;
	tom.setAge(31);
	std::cout << "Name: " << tom.getName() << "\tAge: " << tom.getAge() << std::endl;
	return 0;
}

И в плане конечного результата программы мы не увидели бы никакой разницы.

Когда использовать структуры? Как правило, структуры используются для описания таких данных, которые имеют только набор публичных атрибутов — открытых переменных. Например, как та же структура person, которая
была определена в начале статьи. Иногда подобные сущности еще называют аггрегатными классами (aggregate classes).

НазадВперед

Объединения

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

union ИмяОбъединения{ тип ИмяОбъекта1; тип ИмяОбъекта2; . . . тип ИмяОбъектаn;};

Объединения применяются для следующих целей:

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

Например, удобно использовать объединения, когда необходимо вещественное число типа float представить в виде совокупности байтов

123456789101112131415161718

#define _CRT_SECURE_NO_WARNINGS#include <stdio.h>#include <stdlib.h>union types{ float f; unsigned char b;};int main(){ types value; printf(«N = «); scanf(«%f», &value.f); printf(«%f = %x %x %x %x», value.f, value.b, value.b, value.b, value.b); getchar(); getchar(); return 0;}

Пример

123456789101112131415161718192021222324

#define _CRT_SECURE_NO_WARNINGS#include <stdio.h>#include <stdlib.h>int main() { char temp; system(«chcp 1251»); system(«cls»); union { unsigned char p; unsigned int t; } type; printf(«Введите число : «); scanf(«%d», &type.t); printf(«%d = %x шестн.\n», type.t, type.t); // Замена байтов temp = type.p; type.p = type.p; type.p = temp; printf(«Поменяли местами байты, получили\n»); printf(«%d = %x шестн.\n», type.t, type.t); getchar(); getchar(); return 0;}

Результат выполнения

Достоинства структурного программирования

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

Структурное программирование позволяет значительно сократить число вариантов построения программы по одной и той же спецификации, что значительно снижает сложность программы и, что ещё важнее, облегчает понимание её другими разработчиками.
В структурированных программах логически связанные операторы находятся визуально ближе, а слабо связанные — дальше, что позволяет обходиться без блок-схем и других графических форм изображения алгоритмов (по сути, сама программа является собственной блок-схемой).
Сильно упрощается процесс тестирования и отладки структурированных программ.

Вложенные циклы

В Си допускаются вложенные циклы, то есть когда один цикл находится внутри другого:

for (i = 0; i<n; i++) // внешний цикл — Цикл1{ for (j = 0; j<n; j++) // вложенный цикл — Цикл2 { ; // блок операций Цикла2 } // блок операций Цикла1;}

Пример

1234567891011121314

#define _CRT_SECURE_NO_WARNINGS // для возможности использования scanf#include <stdio.h>int main() { for(int i=0; i<10; i++) // цикл для десятков { for (int j = 0; j < 10; j++) // цикл для единиц { printf(«%2d «, i * 10 + j); // выводим вычисленное число (2 знакоместа) и пробел } printf(«\n»); // во внешнем цикле переводим строку } getchar(); // scanf() не использовался, return 0; // поэтому консоль можно удержать одним вызовом getchar()}

Результат выполнения