
- •Цели программирования
- •Области языков программирования. Научные приложения.
- •Области языков программирования. Коммерческие приложения.
- •Области языков программирования. Искусственный интеллект.
- •Области языков программирования. Системное программирование.
- •Области языков программирования. Языки сценариев.
- •Области языков программирования. Web-программирование.
- •9. Уровни языков программирования. Языки ассемблера(история возникновения, отличительные особенности, пример языков).
- •10. Уровни языков программирования. Языки высокого уровня(история возникновения, отличительные особенности, пример языков).
- •11. Методы реализации программ. Компиляция (схема получения результата из исходного кода, преимущества и недостатки, сравнительная таблица).
- •12. Методы реализации программ. Интерпретация (схема получения результата из исходного кода, преимущества и недостатки, сравнительная таблица).
- •14. Методы реализации программ. Трансляция (схема получения результата из исходного кода, преимущества и недостатки, сравнительная таблица).
- •15. Критерии качества программ:
- •16. Алгоритм:
- •17. Способы записи алгоритма. Блок-схемы.
- •18. Способы записи алгоритма. Псевдокод.
- •19. Способы записи алгоритма. Сравнение различных подходов:
- •22. Концепция памяти
- •23. Принципы типизации данных.
- •24. Иерархия простых типов данных.
- •25. Смотри таблицу в конспектах
- •26. Правила приведения типов.
- •27. Оператор sizeof.
- •28. Переменные (объявление, инициализация, присвоение).
- •29. Константы. Специальные символы. Квалификатор const.
- •30. Область видимости переменных.
- •31. Операторы управления областью видимости.
- •32. Группы операций (особенности записи, таблица приоритетов).
- •37. Структурное программирование: историческая справка.
- •38. Принципы структурного программирования.
- •39. Структурное программирование: три базовые конструкции.
- •40. Основные операторы.
- •Пустой оператор.
- •Оператор присваивания (синтаксис, логика работы, полная и сокращённая форма, порядок выполнения, контекст вычисления, пример).
- •Составной оператор (синтаксис, логика работы, пример).
- •Условный оператор.
- •Неоднозначность условного оператора .
- •Оператор выбора (синтаксис, логика работы, пример)
- •48. Цикл с предусловием.
- •49. Цикл с предусловием.
- •50. Цикл с параметром
- •51. Взаимозаменяемость циклов
- •52. Оператор break
- •53. Оператор continue
- •54. Оператор ?: (синтаксис, логика работы, пример)
- •55. Ссылки (понятие, способы применения).
- •56. Подпрограммы (синтаксис, виды подпрограмм, контекст, пример).
- •57. Оператор return.
- •58. Прототипы функций (понятие, назначение, способы применения).
- •59. Библиотеки функций. Оператор #include.
- •60.Создание пользовательских библиотек
- •61. Способы передачи параметров в функции.
- •Способы передачи значения из одной функции в другую.
- •63. Рекурсия
- •64. Значения по умолчанию.
- •65. Перегрузка функции.
- •66.Перезагрузка операторов.
- •67.Шаблоны функций.
- •68. Разрешение неоднозначности при вызове функций.
- •69. Одномерные массивы (объявление, индексация, хранение в памяти, сортировка).
- •70. Типовые алгоритмы обработки элементов массива.
- •71.Двумерные массивы
- •72. Представление двумерного массива в виде одномерного. Соответствие индексов двумерного и одномерного
- •73. Многомерные массивы (объявление, индексация, хранение в памяти, сортировка). Пример
- •74. Указатели (назначение синтаксис, операции).
- •75. Различие между указателями и ссылками.
- •76. Динамическая память (выделение и освобождение памяти под переменные, одномерные массивы, двумерные массивы).
- •77. Тип данных «Массив массивов»
- •78. Представление строк в языках программирования. Достоинства и недостатки различных представлений (отличие ‘a’ от “a”).
- •Функции библиотеки cstring
- •Макросы
- •Типы данных
- •82. Файлы (понятие, текстовые и двоичные файлы, структурированные и неструктурированные, операции, основные библиотеки для работы с файлами).
- •Файловый ввод-вывод с использованием потоков
- •83. Потоковый ввод-вывод. Библиотека потокового ввода-вывода.
- •85. Файловый ввод-вывод. Стандартная библиотека ввода-вывода
- •87.Типовые алгоритмы обработки файлов
- •89.Создание простых бд с помощью массива структур.
- •90. Списки (определение, типовые операции, использование).
- •91. Создание простых бд с помощью списков.
29. Константы. Специальные символы. Квалификатор const.
Единственное отличие констант от переменных, что после инициализации их нельзя изменить. Константы удобны в следующих случаях. Вы хотите улучшить понимание своей программы для других, ведь смысловое имя более понятно чем какое-то число.
Если в вашей программе многократно используется некое число, например 7. Но в дальнейшем оно может изменится на другое. То легче один раз объявить константу и когда надо заменить один раз значение у константы.
константы
Константные ссылочные типы часто используются в качестве аргументов для функций, чтобы гарантировать не изменность данных.
// инициализирующее выражение обязательно
const int ci1=6, ci7=7;
// объявление константы определенной в другом модуле
extern const int a;
int func(const char* arg){
// данные на которые указывает arg
// нельзя изменить
...
}
Спец.символы.
У символьных и строковых литералов есть определенные особенности, как управляющие коды. Они - специальные символы, которые являются трудными или невозможными выразить иначе в исходном коде программы, как новая строка (\n) или вкладка (\t). Всем им предшествует наклонная черта влево (\). Здесь у Вас есть список некоторых из таких управляющих кодов:
\n новая строка
\r возврат каретки
\t вкладка
\v вертикальная вкладка
\b клавиша Backspace
\f перевод формата (нумеруют страницы канала),
\a предупреждение (звуковой сигнал)
\' одинарная кавычка (')
\" двойная кавычка (")
\? вопросительный знак (?)
\\ наклонная черта влево (\)
Квалификатор типов const (от анг. type qualifier) – зарезервированное ключевое слово в языке программирования С++, которое не даёт модифицировать значения переменных. Отсюда и возникло в программировании такое понятие, как константы или константные переменные, то есть неизменные. Необходимо запомнить, что при объявлении константы, её нужно инициализировать.
//Синтаксис объявления константы
const /*тип данных*/ /*имя переменной*/ = /*инициализатор ( значение) */; // объявление константной переменной
Объявление константной переменной от обычной переменной отличается ключевым словом const, которое ставится перед типом данных объявляемой переменной.
Когда пишутся большие программы, где тысячи строк кода, то такую ошибку будет очень сложно отследить. Таким образом, если нет необходимости изменять значение переменной, то лучше подстраховаться и объявить эту переменную как константу.
30. Область видимости переменных.
Область видимости (англ. scope) — в программировании обозначает область в которой в данный момент можно обратиться по имени к переменным и функциям.
Переменные по области видимости делятся на два типа:
• локальные, когда переменная объявляется внутри функции, в таком случае изнутри вызвать эту переменную не получится;
• глобальные, когда переменная объявляется вне всех функций, в таком случае она доступна ото всюду[1][неавторитетный источник?].
Область видимости переменной может задаваться с помощью классов памяти или пространства имён.
В качестве обучающего примера попробую описать область видимости переменных с помощью функций.
Первый вариант – глобальная переменная. Глобальная переменная объявляется один раз и действует по всей программе
Код C++ Глобальная переменная
#include <conio.h>
#include <iostream.h>
void main(); //Прототип функции main
void sum(); //Прототип функции sum
//Обратите внимание, что переменные объявляются вне функций
int i=100; //Глобальная переменная i. При объявлении запоминаем в i некоторое значение
int a; //Глобальная переменная a
void main()
{
clrscr();
a=200;//так как a была объявлена вне функции - она глобальная и значит доступна по всему коду
sum(); //Вызываем некоторую функцию
return;
}
void sum()
{
cout<<i<<endl; //Выводим значение переменной i на экран = 100
cout<<a<<endl;//Выводим значение переменной a на экран = 200. Значение 200 было записано в main
cout<<i+a<<endl; //Выводим значение i+a на экран = 300
getch();
return;
}
Глобальная переменная объявляется вне тела функций и доступна она до конца программы. В приведенном примере вне функций было объявлено две переменные. К каждой из них можно обратиться в любом блоке программы. При этом последнее запомненное значение таких переменных остается в памяти и доступно для последующей обработки.
Смысл этого можно понять, посмотрев приведенный пример. Персонально для функции sum переменных создано не было, но несмотря на это я смог с помощью sum вывести верные значения переменных на экран. Смог потому что объявил их вне тел функций , а значит сделал глобальными, т.е доступными для любой другой функции (любого другого блока программы).
Если я плохо объяснил, что обозначает глобальная переменная, то я неудачник. Если хорошо, то имеет смысл читать дальнейшее описание. Помимо понятия Глобальная переменная – существует Локальная переменная. Локальная переменная определяется внутри функции и доступна она только для функции, внутри которой была объявлена.
Код C++ Локальная переменная
#include <conio.h>
#include <iostream.h>
void main(); //Прототип функции main
void sum(); //Прототип функции sum
void main()
{
int a; //Объявили переменную внутри main, т.е. объявили локально
a=200; //Переменная объявленная внутри main доступна только и только внутри main
return;
}
void sum()
{
int i;//Объявили переменную i внутри sum. Другими словами объявили локальную переменную i
cout<<i<<endl; //Выводим на экран i
cout<<a<<endl; //Тут должна быть ошибка
cout<<i+a<<endl;
getch();
return;
}
Ошибка в указанном месте возникает из-за того, что для функции sum не действует никакая переменная, объявленная внутри любой другой функции. Если программист объявляет переменную внутри некоторой одной функции, значит он предполагает, что с этой переменной будет работать только и только та функция, в которой переменная была объявлена. Такие переменные живут только внутри своих функций и не доступны для других участков кода. Это и есть локальная переменная. В отличии от первого приведенного примера, в этом примере глобальных переменных объявлено не было. Значит по факту для sum переменной a не существует в природе.
Существует ситуация, когда программист объявляет глобальную и локальную переменные с одинаковыми именами. В этом случае во время работы функции с локальной переменной локальная переменная закрывает глобальную и говорит: “Я тут главная”. Непосредственная работа выполняется с локальной переменной, при этом значение глобальной переменной остается в памяти
Код C++ Локальная переменная затеняет глобальную
#include <conio.h>
#include <iostream.h>
void main(); //Прототип функции main
void sum(); //Прототип функции sum
void new_fun(); //Прототип функции new_fun
int i=100; //Глобальная переменная i
void main()
{
cout<<i<<endl; //В этом случае i глобальная, т.к. внутри main i объявлено не было i=100;
sum(); //Вызывам некоторую функцию
new_fun(); //Вызываем некоторую функцию
getch();
return;
}
void sum()
{
int i=20;//Переменная i локальная т.к. объявлена внутри sum. Действует только внутри sum
cout<<i<<endl; //Выводим на экран i. Локальная i затенила глобальную (действующая i=20). Глобальная i висит в памяти
return;
}
void new_fun() //Внутри new_fun переменных не объявлено, значит для new_fun существуют только глобальные переменные
{
cout<<i<<endl; //Выводм на экран глобальную i (i=100)
return;
}
В случае когда программист объявляет глобальную переменную и одноименную с ней локальную, локальная затеняет глобальную. При вызове функции с локальными переменными, локальные переменные по приоритету выше глобальных. Так как локальные переменные по приоритету выше, значит значения для вычислений берутся из них. По завершении функции глобальная переменная вновь приобретает силу. Это можно понять по приведенному примеру. Вне функций была объявлена некоторая переменная i (вне = глобальная), вместе с ней внутри функции sum была объявлена еще одна переменная i (внутри = локальная).
В последнем примере было описано, что обозначает выражение “локальная переменная затеняет глобальную”. Так как глобальная переменная не теряет своего значения, то программист может обратиться непосредственно к ней внутри функции с одноименной локальной переменной . Для такого обращения используется глобальный оператор разрешения
Код C++ Глобальный оператор разрешения
#include <conio.h>
#include <iostream.h>
int i=100;//Глобальная переменная i
void main()
{
clrscr();
int i=50; //Локальная переменная i
cout<<i<<endl; //Обращение к локальной переменной (i=50)
cout<<::i<<endl; //Обращение к глобальной переменной (i=100) Использован глобальный оператор разрешения
getch();
return;
}
Такое описание было написано для тех начинающих, которым надо всё поподробнее растолковать. Самое главное запомнить понятие локальной и глобальной переменных
• Локальная переменная – такая переменная, которая объявляется внутри функции и действует она только внутри своей функции (видима только своей функции)
• Глобальная переменная – такая переменная, которая объявлена вне функции и доступна она для окончания работы программы (видима всей программе)
Несмотря на описанные возможности не рекомендуется применять переменные с одинаковыми именами. Во избежание путаницы следует избегать глобальных переменных везде где возможно. Это важно помнить.