1.Структура программы
Любая программа, написанная на Си, состоит из одной или нескольких функций, являющихся основными модулями, из которых она собирается. Функция, с которой начинается выполнение программы, всегда носит имя "main". Пары символов /* и */ используются в качестве открывающей и закрывающей скобок для комментария, в Си++ строка комментария начинается парой символов //. Составные операторы (операторы, состоящие из нескольких простых) заключаются в фигурные скобки. Открывающая фигурная скобка также отмечает начало тела функции, закрывающая - его конец (аналог begin - end).
Одной из особенностей языка Си является чувствительность к регистру. Если в языке паскаль идентификаторы elem, Elem, ELEM являются одним и тем же идентификатором, то в Си это 3 разных идентификатора. Идентификаторы должны начинаться с буквы или знака подчеркивания и могут состоять из букв, цифр, _, $. Значимы по умолчанию первые 32 символа. В Си «;» служит концом любого оператора. Слова Begin – End в значении начала и конца в разделе реализации программы или подпрограммы, а также в начале и конце составного оператора на Си заменяются фигурными скобками.
Общая структура программы на языке С:
{Директивы препроцессора}
<Описание типов>
|
<Описание переменных>
<Прототипы функций>
<Описание функций>
Функции имеют следующую структуру:
Тип_Функции Имя_Функции (Параметры)
{
<Локальные описания>;
<Операторы>;
}
Директивы препроцессора в том числе используют и для подключения файлов заголовка. Ф айлы заголовка, определяются стандартом ANCI C. Файлы заголовка, называемые также включаемыми файлами, содержат объявления прототипов библиотечных функций. В них также находятся определения типов данных и символических имен констант библиотечных функций, а также глобальные переменные, определяемые C++ и библиотечными функциями. Имена файлов заголовка и их содержимое в библиотеках Turbo C++ следуют стандарту ANSI C. Ниже приведены наиболее часто используемые в настоящих лабораторных работах заголовочные файлы.Подключаются директивой #include.
#include <имя файла>
#include "имя файла"
Когда препроцессор встречает директиву #include, он ищет следующее за ней имя файла и включает его в текущий файл. Угловые скобки сообщают препроцессору о том, что файл следует искать в одном или нескольких стандартных системных каталогах. Кавычки
говорят о том, что сначала нужно смотреть в вашем каталоге, а затем искать в стандартных.
Файлы включают потому, что они несут полезную информацию. Например, в файле string.h определены функции работы со строками, в iostream.h, stdio.h - функции ввода / вывода.
По соглашению суффикс.h используется для заголовочных файлов, то есть файлов с информацией, которая располагается в начале вашей программы.
| conio.h | - | Объявляет различные функции, используемые при вызове подпрограмм DOS ввода/вывода с консоли. Содержит прототипы функций clrscr(). |
| graphics.h | - | Объявляет прототипы графических функций |
| iomanip.h | - | Объявляет манипуляторы ввода/вывода потоков С++ и содержит макрос для создания параметризованных манипуляторов |
| iostream.h | - | Объявляет подпрограммы (ввода/вывода) потоков базового С++№ Прототипы функций cout, cin. |
| math.h | - | Объявляет прототипы математических функций |
| stdio.h | - | Определяет типы данных и макросы, необходимыедля пакета стандартного ввода/вывода (Standard I/O Package), определенного Керниганом и Ритчи. Определяет предопределенные потоки стандартного ввода/вывода stdin, stdout, stdprn и stderr, а также объявляет подпрограммы ввода/вывода уровня потоков. Содержит прототипы функций printf, scanf. |
| stdlib.h | - | Объявляет некоторые широко используемые подпрограммы: подпрограммы преобразования, подпрограммы поиска/сортировки и прочие. Содержит прототипы функции randomize, random. |
| string.h | - | Объявляет несколько подпрограмм строковых манипуляций и манипуляций с памятью |
| time.h | - | Определяет структуру, заполняемую подпрограммами преобразования времени asctime, localtime и gmtime, а также тип, используемый подпрограммами ctime, difftime, gmtime, localtime и stime; также содержит прототипы этих подпрограмм. |
2.Основные типы языка
Язык Си имеет следующие основные простые типы:
1. числовые;
2. логические;
3. строчные;
4. указатели.
Числовые типы в свою очередь подразделяются на целочисленные и вещественные. Целочисленные – short int, int, long. Каждому из этих типов может быть добавлена директива unsigned (без знака), с учетом этого имеем целый ряд целочисленных типов:
Short – 2 б – -32768 … +32767
Int – 2 б – -32768 … +32767
Unsigned int – 2 б – 0 … +65535
Long – 4 б – -231 … 231-1 – -2 147 483 648 …. +2 147 483 647
Unsigned long – 4 б – 0 … 231-1 – 0 … 4 294 967 295
Вещественные типы (с плавающей точной):
Float – 4 б – 3.4 * 10-38 … 3.4*1038
Double – 8 б – 1.7 * 10-308 … 1.7*10308
Long double – 10 б – 3.4 * 10-4932 … 1.1*104932
Типы float, double и long double представляют числа с плавающей точкой соответственно одинарной, двойной и повышенной точности.
Выражения в которых требуются логические значения интерпретируют значение 0 – false, а все другие отличные от 0 значения – true.
3. Объявление (определение) переменной. Инициализация. Константы
Объявление переменных определенного типа производится следующим образом:
<имя типа> <идентификатор>;
где <имя типа> - ключевое слово, указывающее на тип данных,
<идентификатор> - имя переменной.
Например:
int index;
int height;
char ch;
char next;
long double price;
Когда определяется несколько идентификаторов переменных данного типа, то за спецификацией типа располагается список имен, разделенных запятыми.
Предыдущее определение можно переписать так:
int index, height;
char ch,next;
long double precision;
Такое определение не задает начального значения и о таких переменных говорят, что они неинициализированы. При этом значение переменной не определено, а на практике обычно является случайным. Может случиться, что одна и та же программа дает разные результаты при одинаковых исходных данных, обычно это происходит из-за неинициализированных переменных.
Начальное значение может быть задано при определении переменной. Переменная с заданным начальным значением называется инициализированной переменной. Язык Си поддерживает явную форму инициализации переменной - через операцию присваивания.
Например
int index = 1000;
Язык С++ добавил к этому еще одну форму инициализации - неявную, при которой начальное значение располагается внутри скобок:
Например
int index(1000);
Переменные могут инициализироваться сколь угодно сложными выражениями, включающими вызовы функций и т.п.
Массивы в С объявляются следующим образом
<имя типа> <идентификатор> [размерность];
Например:
int I [30]; // объявление массива размерностью 30 чисел типа int.
Диапазон индексов на С в отличии от языка Паскаль всегда начинается с 0 и заканчивается (n-1), где n – размерность. То есть применительно к вышеприведенному примеру диапазон индексов - от 0 до 29 включительно.
Многомерные массивы объявляются соответственно:
<имя типа> <идентификатор> [размерность 1][размерность 2][размерность 3] …;
Например:
int I [4][5][6];
В С++ определения переменных могут располагаться в программе где угодно - в любом месте, где допустим оператор (определение переменной считается оператором). В С было не так - определения переменных должны были следовать за открывающей фигурной скобкой блока и предшествовать первому исполняемому оператору функции. Это различие сразу бросается в глаза при переходе с С на С++ и это большое удобство. Можно определять переменные там, где возникает в них необходимость, а не в отведенном для этого месте.
Часто в программах встречаются константы, которым имеет смысл дать имя. Значение константы нельзя изменить в программе. Такие константы определяются с помощью модификатора const.
Например
const int max = 512;
И в случае изменения величины max нужно изменить только одну строку в программе. Поскольку такая константа (ее называют именованной или символической константой) не может быть изменена после своего определения, то она обязательно должна быть инициализирована.
Такая запись будет ошибкой:
const int max; // нет инициализации
и такая – тоже:
max = 1024; // это константа!
Раньше спецификатора const в языке С не было. Он появился с появлением стандарта ANSI и оттуда перешел в С++. В то же время препроцессор позволяет определять текстовую подстановку с помощью директивы #define.
Например если мы напишем
#define MAX 512
(слева - имя, справа - текст, без точки с запятой в конце), то все вхождения имени MAX в тексте программы перед компиляцией заменятся на 512 (и вообще на текст до конца строки).
Например,
if (i < MAX) { }
заменится на
if (i < 512) { }
Никаких проверок при такой замене не делается - просто текстовая подстановка. Недостатки такого подхода:
1) компилятор не знает имени MAX - оно уже заменено препроцессором на 512. Следовательно, нет объекта с таким именем, и у него нет типа. Отсюда следует, что, если у нас будет какая-то ошибка, относящаяся к оператору с MAX, то сообщения компилятора к этому имени относиться не будут и скорее всего будут непонятными.
2) никакой отладчик не позволит посмотреть или как-либо иначе использовать значение MAX.
Eсли же пользоваться const, то этого не случится - max - объект в программе (только неизменяемый). У него есть тип и его значение можно посмотреть в отладчике.
Работая с С++, всегда для констант используйте const.
Тип перечисление определяет множество символических целых констант. Эти константы называются элементами перечисления. Отличие от эквивалентных им описаний со спецификацией const состоит в том, что нет адреса памяти, связанного с каждым элементом перечисления. Перечисление описывается служебным словом enum и разделенным запятыми списком элементов перечисления. Список заключен в фигурные скобки. По умолчанию первому элементу присваивается значение 0, а каждому последующему - на единицу больше, чем значение предыдущего элемента.
Различают именованные и неименованные перечисления. Неименованные перечисления просто связывают некоторый список констант со значениями:
enum { false, true };
Теперь false значит 0, а true значит 1.
i = false; значит то же, что и i = 0;
Значение может явно присваиваться элементу перечисления. Если каким-то из элементов значение присваивается, а каким-то нет, то значение тех элементов, которым присваивания не было, на единицу больше предыдущего.
Например:
enum { false,close = 0, open, true = 1 };
Здесь false и close будут 0, а open и true - 1.
Именованные перечисления задают уникальный целочисленный тип и могут использоваться как спецификация типа для определения переменных:
Например:
enum boolean { false, true };
boolean found = false;
Переменная found будет типа boolean.
В этом случае множество элементов перечисления будет представлять собой исчерпывающий список значений, которые можно присваивать объектам такого типа.
Например
found = true;
будет правильным присваиванием, а
found = 100;
вызовет ошибку.
4. Определение строки
Так как в Си не существует встроенного строкового типа данных, то для создания переменных строкового типа необходимо создать массив символов. Причем последним элементом этого массива всегда будет нуль-символ '\0'. Он используется для того, чтобы отмечать конец строки. Наличие нуль-символа означает, что количество ячеек массива должно быть по крайней мере на одну больше, чем число символов, которые необходимо размещать в памяти. Инициализация строк может производиться следующим образом:
char m1[] = "Строка символов";
char m[44] = "Новая строка символов";
5. Операторы ввода/вывода
Функция printf, вывода на экран, требует подключения файла stdio.h. Имеет простой и гибкий формат.
printf (“Строка формата”, объект 1, объект 2);
Строка формата – строка, которая начинается и заканчивается двойными кавычками и выводится на экран. Кроме того, в строке формата могут присутствовать спецификации формата, которые указывают как необходимо выводить объект.
Например:
printf(“Сумма=%d\n ”,sum);
Строкой вывода является - Сумма = - а спецификацией является %d. Все спецификации формата начинаются с символа % и обычно сопровождаются одной буквой, обозначающей тип данных и способ их преобразования. Для каждого объекта необходимо иметь только одну соответствующую ему спецификацию формата. В программе объектом является переменная sum, ей соответствует спецификация формата %d. %d используемый в программе говорит о том, что ожидается некоторое целое число. Ниже приведены некоторые другие спецификации формата.
| %u | - | целое число без знака; |
| %p | - | значение указателя; |
| %f | - | вещественное число; |
| %e | - | вещественное число в экспонентной форме; |
| %s | - | строка; |
| %x | - | Целое число в шестнадцатеричном формате. |
Можно также задать ширину выводимого поля, помещая её между знаком % и буквой. Например, поле шириной 4 задается %4d. Ширина поля с плавающей точкой задается следующим образом %6.2f (аналогично паскалевскому 6:2).
Например:
printf(“ %6.2f ”,r); // C
write(r:6:2); {Pascal}
Если требуется выравнивание содержимого поля по левому краю (по умолчанию правое выравнивание), можно использовать так называемые флаги. Необязательная последовательность флагов, используется для включения вывода и печати знаков, пробелов, десятичных точек. Может принимать некоторые следующие значения:
| - | - | выравнивание результата влево внутри поля с заполнением пробелов справа; |
| + | - | присоединение знака + к выводимому значению если оно знакового типа; |
| пробел | - | К выводимому значению присоединяется пробел вместо + если выводимое значение знаковое и положительное. Отрицательные значения начинаются с – и без пробела; |
Например:
printf(“ %-6.2f ”,r);
Обратный слеш (\) – это не спецификация формата, а управляющий символ и представляет собой специальный символ, вставленный в строку. Например, \n в программе является символом перевода курсора на новую строку. Функция printf с использованием \n работает как writeln в Паскале. Ниже приведены часто втречающие управляющие символы.
| \f | - | очистка экрана; |
| \t | - | символ табуляции; |
| \b | - | забой (backspace) забивает предыдущий символ; |
| \a | - | сигнал динамика; |
Объектами при вызове функции printf может быть переменная, константа, выражение, а также вызываемые функции, то есть они могут быть чем угодно, что дает соответствующее значение спецификации формата.
Парная предыдущей функции функция scanf – функция ввода - имеет следующиё формат:
scanf(“Строка формата”, адрес1, адрес2, …);
Строка формата иммет тот же вид, что и строка формата функйии printf. Объекты же, следующие за строкой, должны бать адресами, а не значениями.
Например:
int a,b;
scanf(“%d %d”,&a,&b);
Этот вызов сообщает программе, что она должна ожидать ввода двух целых чисел, разделенных пробелом (табуляцией, символом перевода строки). Первое из введенных чисел будет присвоено переменной а, а второе b. Если, например, необходимо разделить вводимые числа запятой, то вызов функции scanf будет иметь следующий вид:
scanf(“%d, %d”, &a,&b);
Если необходимо ввести строку, объявленную как char st[30]; (массив из 30 символов), то необходимо:
scanf(“%s”,st);
Поскольку st является массивом символов, то значение st – адрес самого массива (смотри тему указатели), по этой причине перед st в вызове функции scanf амперсанд (&) не ставиться. При вводе строк с использованием scanf возникает проблема невозможности ввода строки, содержащей пробелы внутри, так как функция scanf принимает любой пробел за признак конца строки.
Например:
«Системный подход – девиз инженера – системотехника!»
введется только «Системный».
Выходом из положения является применение функции gets.
Функции ввода gets, getch. Функция gets читает все, что набирается на клавиатуре пока не будет нажат Enter. Она не помещает символ ввода в в строку, однако добавляет в конец строки нулевой символ.
Например:
char name[60];
printf(“Как вас зовут?”);
gets(name);
print(“Привет, %s ”, name);
Функции, getch читает единственный символ с клавиатуры не выдавая его на экран, то есть без эховывода, аналогично функции readkey в Паскале, и не имеет параметров.
Наример:
char ch;
ch = getch();
Язык С++ к вышеприведенным функциям ввода/вывода добавил функции cout (вывод) и cin (ввод). Эти функции требуют подключения файла iostream.h. Функция cout (читается как «си аут») и функция cin (читается как «си ин») имеют следующие форматы:
Например:
int a,b;
cout<<”Введите значение переменной а = ”;
cin>>a;
cout<<”Введите значение переменной b = ”;
cin>>b;
int s;
s = a+b;
cout<<”Сумма = ”<<s<<”\n”;
6. Разбор типового варианта
Разработать программу, которая вводит фактические данные из таблицы, представленной в Вашем варианте индивидуального задания и выводит на экран таблицу, подобную той, которая находится в индивидуальном задании (включая заголовок и примечания).
| Скорость звука в жидкостях | |||
| Вещество | Тип | Температура (град.С) | Скорость (м/сек) |
| Анилин | Ч | 1656,25 | |
| Ртуть | Ч | 1451,27 | |
| Кедровое | М | 1406,75 | |
| Тип жидкости: Ч - чистое вещество, М - масло |
В соответствии с заданием определяем, что вводу подлежит содержимое таблицы, затем введенные данные упорядочиваются и выводятся на экран в виде представленной таблицы. Данные легче организовать в виде массивов следующих типов: строковый (наименование вещества), символьный (тип вещества), целочисленный (температура), вещественный (скорость). Ввод массивов желательно организовать с помощью операторов цикла (смотри следующую тему). Исходя из вышесказанного составим программу ввода данных разных типов и упорядоченного вывода на экран.
#include <iostream.h> // подключаем директивы препроцессора
#include <conio.h>
#include <stdio.h>
main () // главная функция
{
char vesh[3][10], type[3]; // объявление переменных
int temp[3];
float speed[3];
clrscr();
for (int i=0; i<3; i++) // ввод данных с помощью цикла
{
cout<<"Введите вещество "<<i+1<<" "; // запрос
cin>>vesh[i]; // ввод
cout<<"Введите тип "<<i+1<<" ";
cin>>type[i];
cout<<"Введите температуру "<<i+1<<" ";
cin>>temp[i];
cout<<"Введите скорость "<<i+1<<" ";
cin>>speed[i];
cout<<"-------------\n";
}
clrscr(); // очистка экрана перед выводом таблицы
printf("|------------------------------------------------------|\n");
printf("| Скорость звука в жидкостях |\n");
printf("|------------------------------------------------------|\n");
printf("| Veshestvo | Tip | Temperaura | Scorost |\n"); //выводим шапку таблицы
printf("|------------------------------------------------------|\n");
for (i=0; i<3; i++) // вывод данных через циклический оператор
{
printf("|%-13s|%-8c|%12d|%9.2f|\n",vesh[i],type[i],temp[i],speed[i]); // выводим и
//выравниваем данные с учетом ширины полей каждого
//столбца в шапке и типов данных
printf("|------------------------------------------------------|\n");
}
getch(); // задержка экрана
return 0; // функция вовращает 0
}