Введение или зачем эта книга?

Эта книга - лакомый кусочек для тех, кто любит бить по кнопкам и не любит много читать. Только готовые программы и минимум печатного текста! Взамен вы платите мне своим доверием и вниманием. С помощью принятой мною системы К.А.К., вы быстро отыщите нужный Вам вопрос. Для того, чтобы эффективно работать нам потребуется компиллятор (Visual C++ 6.0 или Borland C++ 3, причём второй вариант желательнее!), мало-мальски работающий компьютер и конечно большая чашка хорошего кофе! Вот всё, что нужно начинающим волшебникам!

Итак...

КАК организовать ввод, чтобы не "делать выводы"?

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

КАК сложить два числа?
КАК вывести данные на экран?
КАК получить число с клавиатуры?
КАК ввести своё имя и увидеть его на экране?
КАК отличаются данные?
КАК пройти в большую математику?


Вопрос: "КАК сложить два числа?"

Для того, чтобы сложить два числа, мы должны создать для каждого из них переменную, которая будет хранить каждая своё число. И ещё одну переменную, в которой будет храниться ответ - то, что получилось после сложения. Заключительный аккорд - вывод ответа на экран! Приступим?

#include <stdio.h>

void main()
{
int a=2, b=3; //объявляем две целые переменные
int c; //в этой переменной будет храниться ответ
c=a+b; //Это наша сложнейшая формула
printf("Ответ: c = %d", c); //Вывод на ответа на экран
}

Пояснения

С помощью директивы #include мы подключили библиотку ввода-вывода stdio.h, которая понимает функцию printf, необходимую для вывода на экран. Без этой библиотеки компилятор не поймёт что такое printf. В языке СИ практически нет своих функций, которые являются частью языка. Это позволяет подключать библиотеки только для тех функций, которые мы используем, которые нам действительно нужны. Как результат - очень малый размер выполнимого EXE-файла, чем язык СИ, вобщем-то и славится! Библиотечные файлы хранятся в папке INCLUDE и имеют расширения *.h (реже *.hpp). Существует понятие "стандартная библиотека" - библиотечный файл из тех, что поставляются вместе с компилятором. Файл stdio.h (standard input output) - одна из тех стандартных библиотек. В нём содержатся стандартные функции ввода-вывода данных.

main() - это главня функция программы на языке СИ. Она есть в каждой программе, и в ней выполянются все те действия, которые мы предусмотрели. Функция main() имеет тело, которое начинается открывающей скобочкой { и заканчивается закрывающей }. Если вы посмотрите на программу, которую мы только что написали, то увидите, что все наши действия не покидают этого тела.

Итак, что же мы сделали? Первым делом мы объявили переменные a и b для двух чисел, которые мы складываем и одну переменную c для ответа. Перед переменными мы написали слово int - что это значит?

int - это тип данных, который при объявлении надо обязатьельно указать. Тип данных - это то, что данные из себя представляют - целые или дробные числа, символы или строки и т.п. В данном случае числа у нас явно целые, поэтому мы отнесли их к типу int - от английского "integer" - "целое", то есть без дробной части. После типа данных указываются имена переменных. Они могут быть почти любые - главное, чтобы они не начинались с цифры и не содержали пробелов и специальных символов.

Например:

int mashina, telega, parohod, samolet;

это допустимые имена переменных. Что же касается:

int 1chelovek; //начинается с цифры - ошибка!
int moja peremennaja; //пробел - ошибка!
int novoe?,/-=chislo; //используются спецсимолы - ошибка!


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

int OdinChelovek; //новое слово начинается с большой буквы
int moja_peremennaja; //символ нижнего подчёркивания, как связка
int novoeChislo; // первое слово начинается в маленькой буквы, следующее с большой

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

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

/*12_06_2006, Иванов: Добавлены переменные для функции цвета*/
int Red, Green, Blue, Yellow;
/*12_06_2006, Иванов: конец кода*/

Два слова о коментариях

Чтобы не читать и не писать сухой программный код, вы можете оставлять в нём заметки. Их оставлять можно и нужно, чтобы разобраться например в программе, которую вы писали месяц назад (или чтобы мог разобраться программист, который эту программу не писал). В коментариях разрешается использовать любые символы и конечно вы можете в них писать по-русски (если конечно редактор кода поддерживает кириллицу). Компиллятор просто пропускает коментарии, поэтому не бойтесь делать в них ошибки. Хорошие редакторы подсвечивают коментарии другим цветом (обычно серым или зелёным), чтобы они не бросались в глаза.
В языке СИ коментарии начинаются со слэша и звёздочки /* и ими же заканчиваются */. В языке Си++ поддерживаются как комментарии языка СИ, так и новые, не требующие закрывающих символов. Начиная с двух слэшей: "//", строка будет считаться комментарием. Мы уже использовали оба этих типа в наших примерах.
Программисты-любители любят рисоваться друг перед другом и говорить, что "комментарии для ламеров", что они им не нужны. Не слушайте их! Старайтесь что бы вы ни писали оставлять как можно больше коментариев, чтобы код можно было читать, как книгу. Как часто их нужно размещать? Ровно столько, чтобы они вам самим не мешали. Когда коментариев больше, чем кода - это тоже не есть хорошо.
Я буду стараться делать их чаще, чтобы мои примеры были понятны. Я надеюсь, что вы будете читать не только код, но и мои комментарии, так как часть материала будет объясняться прямо в них.

О точке с запятой

Ещё один момент. Не забывайте ставтить точку с запятой (;) после каждой строки, так как перевод строки сам по себе для компилятора концом строки не является. Одну строку можно разбить на несколько и переносить сколько угодно. О том, что строка кончилась, мы покажем точкой с запятой. Например:

int a=2,
b=3,
c=4,
d=
1999,
e
=
2022,
f
=707;
//это всё одна строка!

Таким правилам подчиняется на только язык СИ. Большинство языков высокого уровня: Pascal, Delphi, Java, Java Script... требуют ставить точку с запятой после каждой строки кода. Кроме того, точка с запятой, как это не покажется странным может считать операцией. Например, если мы намечаем какой-то фрагмент кода, в котором ещё не знаем что написать, можно обозначить это место точкой с запятой.
{
; ;
}
Так, компилятор, ожидающий в этом месте что-либо, не будет выдавать ошибок и предупреждений.

Вывод на экран

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

Если мы напишем:

printf("Оля любит Колю");

на экране появится эта фраза. Функция выводит на экран то, что находится в кавычках. В простейшем её применении она выводит текст. Мы же её использовали для вывода значения переменной. Помните, мы написали:

printf("Ответ: c = %d", c);


Что у нас тут? До сих пор всё было понятно. Здесь же мы использовали какие-то процентики с = %d. Зачем? Всё очень просто. Вместо %d компилятор подставит значение числа с. О том, что нас интересует именно с, мы дали понять, поместив его после запятой.

Если бы мы хотели вывести все три числа, то надо заменить строку на:

printf("Ответ: %d+%d = %d", a, b, c);


На экране будет выведено: Ответ: 2+3=5. Красота? Красота!

Такой синтаксис язык СИ заимствовал у операционной системы UNIX, в которой широко используется такая подстановка с процентами вместо числа или строки. Примерно тоже можно наблюдать и в MS-DOS если мы пишем пакетный файл *.bat.

А если числа дробные?

А если у нас не целые числа, как быть? Пусть мы хотим сложить 2.3 и 4.7. Это сложно?
Для дробных чисел существует другой тип данных. Если для целых был int, то для дробных float (число с плавающей запятой от слова float - плавать (англ.)). Соответственно вместо %d мы пишем %f. Взгляните:

#include <stdio.h>

void main()
{
float a = 2.3, b = 4.7; //объявляем две дробные переменные
float c; //В этой переменной будет храниться ответ
c = a + b; //это наша сложнейшая формула. Она не меняется
printf("Ответ: c = %f", c);
}

На экране будет: c=7.000000. Откуда так много ноликов? Значение было посчитано с очень большой точностью. Компьютер позволяет нам это сделать. Это важно в различных инженерных расчётах, где точность вычислений должна быть феноменальной. Но иногда такая скрупулёзность только отвлекает и действует на нервы. Как в том анекдоте, где сын спрашивает отца-инженера сколько будет дважды два. Отец надевает очки, долго возится с логарифмической линейкой, а потом серьёзно отвечает: "Сынок, тут что-то около четырёх...".
Если два знака после запятой нас устроят, то мы напишем так:

printf("А ответ у нас всё ещё такой: c=%.2f", c); //.2 - означает, что после точки нам нужны только 2 знака

Дробные числа в расчётах встречаются гораздо чаще, чем целые. Это и курсы валют - "28 долларов и 28 центов" и всякие количественные меры: ёмкость, объём, длина, вес... Их ещё называют вещественными числами или числами с плавающей запятой (точкой), так как число знаков после запятой может меняться. В программировании число знаков после запятой называется красивым словом: "мантисса".

Вывод в языке Си++

А если мы не хотим возиться с типами данных, да и процентики нам надоели? Воспользуемся средствами языка Си++ (до этого мы писали на Си без плюсов):

#include <iostream.h> //сменим библиотеку

void main()
{
float a = 2.3, b = 4.7; //объявляем две дробные переменные
float c; //В этой переменной будет храниться ответ.
c = a + b; //это наша формула. Она не меняется.

cout<< "Ответ: "<<c; //выводим ответ на экран
}

В языке СИ используется библиотека стандартного ввода-вывода ("standart input / output" или stdio.h). В СИ++ используется новая, менее зависимая от типов библиотека iostream.h (input-output stream), основанную на потоках ввода-вывода. Нельзя сказать, какая из них важнее. Каждая из них хороша по своему. stdio.h - наследие операционной системы UNIX, которая вобщем-то и написана на СИ. Стандартным устройством вывода в этой системе может быть не обязательно монитор, но и принтер, плоттер, файл, порт. Вывод в стандартные устройства широко используется при отладке больших проектов, это жизненно необходимо всем программистам на СИ++.

В iostream.h мы лишь избавлены от необходимости форматировать вывод, так как это делается автоматически. Функция cout просто выводит переменную с, даже не спрашивая какого она типа. Она автоматически распознает тип данных. Голова о процентиках не болит! Даже если мы объявим эти числа, как int, в строке с функцией cout ничего не изменится! Правда здорово?
То, что мы узнали новую функцию, разумеется не значит, что мы теперь забудем про "чистый" СИ и stdio.h. Оба эти способа до сих пор широко используются, и мы будем использовать и тот и другой.

Ввод данных

До сих пор мы объявляли переменные и вписывали в них значения прямо в программном коде. Но это хорошо не всегда. Если мы хотим написать программу для расчёта, нам придётся для каждых новых данных заново компиллировать программу, меняя значения a и b. Это не удобно. Почти всегда нужно, чтобы пользователь сам ввёл данные, которые будут подставлены в какую-то формулу. Данные эти могут быть не обязательно числовые. Когда программа просит вас ввести имя пользователя и пароль, это тоже ввод данных, но только текстовых. В окне Windows вы заполняете форму, ввода ваши имя, возраст, пол и год рождения - это тоже ввод данных. Почти всегда если мы говорим о данных, которые вводит пользователь, мы говорим о данных "с клавиатуры".

Итак, как же нам ввести с клавиатуры наши a и b? В Си эта проблем решена так:

#include <stdio.h>

void main()
{
float a, b, c; //объявляем три дробные переменные

printf("Введите первое число: "); //приглашение ввести данные
scanf("%f", &a); //это новая функция. По смыслу можно догадаться - ввод данных. Тот же процентик, только перед a "&"

printf("Введите второе дробное число: ");
scanf("%f", &a); //"&" - амперсанд, надо ставить обязательно!

c=a+b;

printf("Ответ: c = %f", c); //cout использовать не можем, так как у нас подключена библиотека stdio.h, а iostream.h не подключена
}

Ну а на СИ++ это будет выглядеть так-то:


void main()
{
float a,b,c;

cout<<"Введите А: ";
cin>>a; //ввод данных. О типе опять же не печёмся. Только скобочки в другую сторону не забудьте поставить! >>

count<<" Введите B: ";

c=a+b;

cout<< "Ответ: "<<c;
getch();
}

Не правда ли, второй варинат гораздо изящней? :)
Итак, всё по порядку. Функция scanf - обратная по смыслу printf. Она служит для ввода информации с клавиатуры.


scanf("%f", &a);

Первым делом мы указываем тип данных %f, это значит, что число вещественное. Дальше по логике надо было бы написать просто a. Зачем нужен амперсанд? Когда мы вводим переменные, мы должны поместить их в память - занять ими определённое количество ячеек. Значок "&" приказывает компилятору выделить память для хранения данной переменной. Как вы потом увидите, он используется не только в scanf.

Что же касается примера на С++, то тут тоже всё прозрачно. Функция cin позволяет ввести данные с клавиатуры, даже не спрашивая, какого они типа! Две скобочки здесь смотрят в другую сторону и тем самым мы понимаем, что здесь речь идёт о вводе, а не о выводе. А с функцией count вы уже знакомы!

Не стоит считать функции stdio.h архаичными. Они используются и довольно широко, особенно в Интернет-программировании и написании сценариев на языке СИ.

Вопрос: "КАК ввести своё имя и увидеть его на экране?"

Мы всё про числа, да про числа, как будто программирование только для счёта! Приятно было бы, чтобы компьютер, осведомившись, как нас зовут, поздоровался с нами. Как вам такая идея?
Познакомимся с новым типом данных: char. Название происходит от английского "character" - символ. Переменная этого типа хранит один символ. Это может быть буква, цифра, пробел или любой спецсимвол, который может понадобиться в вашей программе.

Например:

char bukva = 'А'; //значение символа хранится в одинарных кавычках

Соответственно, если мы хотим её вывести на экране, надо написать:

printf("У меня есть буква %c", bukva); //обратите внимание - %с

И тогда мы увидим на экране: "У меня есть буква А".
Если же надо ввести символ с клавиатуры, то:

scanf("%c", &bukva);


В чистом виде символы могут использоваться например во всем нам знакомых ситуациях, когда программа спрашивает вас: "Вы уверены, что хотите выйти? (Y/N)". Вы нажимаете Y или N, не догадываясь о том, что тем самым ввели символ, который программа будет обрабатывать.

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

Строка - это последовательность символов, так сказать массив символов, следующих один за другим. Мы уже можем вывести на экран символ: "Я". Если же мы хотим записать в переменную строку: "Я люблю тебя жизнь", одной переменной char нам будет явно недостаточно. Во многих продвинутых языках есть полноценный тип данных String, который отвечает за строки и позволяет с ними работать. Зря вы радуетесь, в языке СИ такого типа нет! :-(

Создатели СИ явно недооценили важность текста, посчитав, что программирование нам нужно будет только для вычислений. В СИ строка - это последовательность символов char, или массив сhar. Массив позволит нам не записывать каждый символ в свою отдельную переменную, а сразу выделить памяти столько, чтобы записать строку в переменную. Но для этого надо указать её длину - чтобы знать, сколько памяти потребуется. Итак...

char massiv_char[19]="Я люблю тебя жизнь!";

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

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

Немного об указателях

Но... - скажете вы, - это ведь жутко неудобно! Это что же каждый раз считать сколько у меня символов?

Не беспокойтесь! Есть и другое решение. В языке СИ существует понятие указатель. Создавая переменную-указатель, мы записываем в неё не значение "Я люблю тебя жизнь", а адрес, по которому хранится эта фраза в памяти. Память будет выделена автоматически, и количество символов указывать будет не надо.

char *ukazatel="Я люблю тебя, жизнь!";

Только что мы объявили... нет не массив символов, а указатель. Знак * - всегда обозначает указатель (кстати он называется модификатор). Он показывает, что мы выделили память для хранения переменной. Тема указателей считается самой сложной в СИ, и если вы поняли то, что я сейчас написал, это прекрасно! Если нет, тоже не беда!

Если же мы создаём указатель на указатель, звёздочки будет уже две!

char **ukazatel_na_ukazaktel; //указатель на указатель

Вернёмся к нашим строкам...

Обратите внимание! Строки заключены в двойные кавычки, в отличие от символов. Вы спросите
- А в строке может быть один только символ?
- Может, - отвечу я.
- А как его тогда обозначать - одинарными или двойными кавычками? - спросите тогда вы.
- Если это строка, то кавычки всё равно должны быть двойными!

char *odin_symbol = "A"; //это строка

А если символ, то одинарными:

char odin_symbol = 'A'; //а
это символ

Распространённая ошибка!

Теперь поговорим об одном очень важном моменте. Мы с вами говорили о том, что

char massiv_char[19]="Я люблю тебя жизнь!";

и

char *ukazatel="Я люблю тебя, жизнь!";

это одно и то же.
Почему? Потому что и в том и в другом случае мы показываем сколько нам нужно выделить памяти. В первом примере мы указываем число символов = 19, во втором не явно - программа сама сосчитает символы и выделит столько памяти, сколько нужно для данной конкретной строки. Но не больше!

И если мы напишем так:

char *odin_symbol;
odin_symbol="Здравствуй мир!";


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

Объявление строк

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

#include <stdio.h>

void main()
{

char stroka[]=""; //мы объявили пустую строку

printf("Как вас зовут?: ");
scanf("%s", stroka); //Обратите внимание - %s, а знак & не нужен

printf("Здравствуйте, %s", stroka);

getch();


}

В данном примере мы объявили пустую строку, задав ей значение по умолчанию.

А разве пустые строки есть? - спросите вы. Сколько угодно. Определив пустую строку так, мы как бы присвоим ей начальное значение, и уже не получим сообщение, что мы используем значение строки, которое не определено.


" Позвольте", - скажете вы, - "только что мы выучили ставить амперсанд в функции scanf, как вы сами же перестаёте его ставить!". Нет, никакой ошибки здесь нет. Знак амперсанд говорит нам о том, что нужно выделить память. Когда мы объявляем массив, явно задавая число элементов, или указатель, то память мы уже выделили. Поэтому второй раз её выделять не нужно, иначе в неё попадёт совсем не то значение, что мы хотели туда поместить!

Всех этих неприятностей лишены программисты на тех языках программирования, где есть тип данных String. Ещё раз пламенный привет авторам языка СИ!

Правильный выбор!

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

char stroka[15];

printf("Как ваше имя?: ");

scanf("%s", stroka);

Уверяю вас, ни один компилятор не посмеет ничего сказать на это. Проблем тоже не будет. Есть ещё один приём записи этого выражения, более распространённый в Си-подобных языках, например в Java:

char *stroka = new char[15];

printf("Как вас зовут?: ");

scanf("%s", stroka);

Здесь мы использовали операцию new, которая появилась только в Си++. Это операция выделения памяти. Такая запись будет работать аналогично предыдущей.

Защита от "дурака"

Но опять у читателя возникает справедливый гнев - а если пользователь введёт больше 15 символов? Как быть если пользователь решит поозорничать? Почти всегда, когда идёт речь о вводе данных с клавиатуры, нельзя говорить о надёжности программы, если в ней нет "защиты от дурака" - проверки корректности данных введённых пользователем. Существует много методов проверки. Например, если пользователь должен ввести имя, надо проверить не является ли то, что он ввёл числом. Если надо получить число, нужно запретить ввод букв. А если вы хотите получить от пользователя E-mail, нужно устроить сложную проверку - присутстствует ли в этой строке знак собака: "@", есть ли точка и соответсвуют ли эти данные формату E-mail. Точно также мы можем вычислить длину строки, введённой пользователем и вернуть его назад, если длина больше, чем нужно. Ещё один способ - считать введённые символы и запретить что-либо вводить после 15-го символа. В Windows-программировании один из параметров текстовых полей ввода - его длина в символах. Так мы сможем легко контроллировать размер данных вводимых пользователем.

А вот теперь - здравствуйте!

Теперь, как я и обещал ввод имени и вывод его на экран!

#include <stdio.h>
#include <conio.h>

void main()
{

char *stroka = new char[15]; //мы объявили пустую строку

printf("Как вас зовут?: ");

scanf("%s", stroka);
printf("Здравствуйте, %s", stroka);

getch();


}

Наверное, к этому времени у вас и вопросов не осталось, поэтому я дам вам маленькое задание - перепишите эту программу для библиотеки iostream.h.

Может быть вы уже испугались, что язык Си ++ сложен, и он не для вас? Тут дело привычки. Понабирав примеры, вы легко к нему привыкните. Утешайте себя тем, что у Си самый сложный в мире синтаксис, а вы его учите, несмотря ни на что! Когда-то я тоже думал, что никогда не привыкну к сложному Си. Потом, спустя какое-то время мне пришлось изучать язык Perl. Вот когда я затосковал по стройности и изящности языка Си!

Вопрос: "КАК отличаются данные?"

Узнав про int, float, char и char *, вы наверняка задумались, а чего это мы ходим вокруг да около? Огласите весь список, пожалуйста! Народ хочет знать какие ещё есть типы!. А то потом будет выясняться...
Не буду томить. Тут я уже табличку-на-пол-странички приготовил... В ней все типы данных, как на ладони.

Тип данных
Обозначение
Принимаемые значения
int
%d
зависит от системы
long
%d
-2147483648-2147483647
float
%f
+/-3,4E+/-38
double
%lf
+/-1,8E+/-308
char
%c
от -128 до 127
unsigned char
%c
0 - 255
short
%d
-32768-32767
unsigned short
%d
0-4294967295


Все типы запоминать не надо. Это информация на будущее. Просто запомните, что double и long - это расширения типов float и int, чтобы оперировать с очень большими числами. Тип short когда-то давал возможность экономить память. Сейчас его применение ограничено.

При программировании больших проектов, стандартные типы данных должны быть у вас уже "в крови". В больших программах создаются новые, свои типы данных. Я их называю "говорящие" типы. Как это делается, скажу позже, однако это очень распространённая практика, и вы тоже непременно с этим столкнётесь. Зачем это нужно? Ну например, создавая тип данных COLOR, вы подразумеваете, что в нём будут храниться только значения цвета. Таким образом, когда вы напишите:

COLOR red;


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

int red;

тот, кто будет читать код, будет долго чесать затылок что же такое red?

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

Вопрос: "КАК пройти в большую математику?"

Знаю, знаю... Математика - это так скучно. После средней школы или тем более института у многих на математику аллергия. Только вот сердитые учителя в школах, колледжах и институтах почему-то очень её любят и не дают нам о ней забывать даже на каникулах. Что за напасть? Но мы их перехитрим и будем делать домашние задания на языке Си, который позволит значительно скрасить нам математические переживания!
ОК. Что мы умеем? Мы умеем вводить разнообразные числа с клавиатуры и выводить их на экран. Что ещё надо? Знать математические операции! Простейшие операции в Си - это сложение (+), вычитание(-), умножение (*), деление (/).
Для того, чтобы решать сложные примеры из домашних заданий нам обычно мало стандартных четырёх действий. Нам бы корень с модулем, да синус с косинусом.


Это в СИ тоже есть:

Вид операции
Тип данных
Функция
Корень
double
sqrt(double)
Синус
double
sin(double)
Косинус
double
cos(double)
Модуль
int
double
abs(int)
fabs(double)
Логарифм
double
double
log(double) - натуральный
log10(double) - десятичный
Арксинус
double
asin(double)
Арккосинус
double
acos(double)
Тангенс
double
tan(double)
Арктангенс
double
atan(double)
Экспонента
double
exp(double)

Итак, как пользоваться этой таблицей? В первой графе я расположил названия функций, которые известны нам из математики. Во второй - тип данных возвращаемого значения. Иными словами, если мы хотим приравнять значение функции корня sqrt какой-то переменной, она должна быть типа double. Этот тип основной при написании математических программ, так как в высшей и вычислительной математике нужны достаточно точные результаты.

И сразу пример. Пусть мы хотим вычислить арифметический квадратный корень:

#include <iostream.h>
#include <math.h>
//математику надо подключать отдельно!

void main()
{
int value; /
/ целое число - из вещественного корень не извлечь!
double answer; //переменная, в которой будет ответ

cout<<"Введите число: ";
cin>>value;
//вводим число

answer = sqrt(value);
cout<<"Корень из "<<value<<" равен: "<<answer;
}


Как видите, всё просто. Раз у функции sqrt тип double, то и переменная answer, которой мы её приравняли того же типа! Поскольку практически все функции таблицы типа double, нам даже ничего не придётся запоминать.

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

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

#include <iostream.h>
#include <math.h>

void main()
{
double ugol = 180; //угол, синус которого надо найти

cout<<"В радианах: "<<sin(ugol)<<endl<<"В градусах: "<<sin(ugol*3.14 / 180);

}

Как известно, чтобы перевести число из радиан в градусы, надо умножить его на 3,14 и поделить на 180. Программа выдест нам синус угла 180 градусов в радианах и в градусах. Здесь мы подсчитываем значение функции прямо в строке вывода. Таким образом, нам не нужно создавать специальные переменные, и мы здорово экономим память!

Подставляя в функцию count "<<endl" мы тем самым переводим каретку, и следующая строка будет выводиться с новой строчки.

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

А потом я скажу вам - ну ладно, хватит строить великих математиков! Переходим к более интересным вещам!

Содержание Вперёд