Уроки по C/C++ (Части с 1 по 20)

К основным типам переменных в C/C++ относятся следующие типы: 1.целочисленные:
Тип Описание Пример объявления
char Символьный тип (один символ) char ch='q';
short или short int Короткое целое. Тип больше или равен типу char short a=28, b;
int Целое число. Тип больше или равен типу short short a=20;
long Целое длинное число. Тип больше или равен типу int long s=3;
2.вещественные:
Тип Описание Пример объявления
float Вещественный тип float a, b, c=0.93;
double Вещественный тип двойной точности. Тип больше или равен типу float double d=56.078;
Обратите внимание, что символьный тип - это один из целочисленных типов. Это, в частности, означает, что переменную такого типа можно превратить в любой другой целый тип. Также обратите внимание, что в один символ мы записываем в одинарные кавычки. Сразу заметим, что несколько символов (строку) мы должны записывать в двойные кавычки.

Часть 2. Массивы

Массив представляет из себя неколько переменных с одним именем и одного типа. К конкретному элементу массива можно обращаться по номеру. Вот пример:
//Объявление массива из 3 элементов.
int z[3];
//Инициализируем элементы массива.
z[0]=4;
z[1]=-4;
z[2]=13;
Обратите внимание, что при объвлении массива мы пишем в квадратных скобках именно столько элементов, сколько нам в надо. Если надо, чтобы в массиве было 10 элементов, значит пишем в квадратных скобках 10. Нумерация элементов массива идет всегда с нуля. Другой возможности нет. Это в частности означает, что последний элемент массива будет иметь номер на 1 меньше, чем количество элементов массива. Т. е. если в массиве 10 элементов, то последний имеет номер 9. Массивы могут быть многомерные. Вот пример:
//Объявление массива из 6 элементов.
int z[3][2];
//Заполняем элементы массива.
z[0][0]=4;
z[1][0]=-4;
Если внимательно посмотреть на объявление двумерного массива, то видно, что фактически он представляет из себя массив массивов. Немного забегая вперед, скажем, что имя массива представляет из себя адрес начала массива (т. е. адрес начального элемента массива). Элементы массива располагаются в адресном пространстве подряд. В частности для быстродействия это означает следующее - для доступа к любому элементу массива достаточно к адресу начала массива прибавить номер этого элемента, умноженный на размер, нужный для одного элемента. Т. е. для доступа к произвольному элементу массива не надо перебирать все предыдущие. В этом массивы отличаются от, например, списков - там для доступа к оперделенному элементу надо перебрать все предыдущие, что, разумеется, отражается на быстродействии. При объявлении массива его размер должен быть известен заранее. Т. е. нельзя, например, сначала запросить у пользователя число n, а потом объявить массив:
int z[n]; //Неверно!
Но если n объявлена перед этим как константа, то такое объявление массива вполне законно.

Часть 3. Циклы for

В любом языке программирования есть, как правило, 2 типа циклов: те, про которые известно, сколько раз они должны выполнится и те, про которые заранее неизвестно, сколько раз они должны выполнится. Пример первого - это запрос у пользователя, например, 10 чисел (ясно, что мы должны повторить это действие 10 раз). Пример второго - запрос пароля у пользователя (неясно заранее, сколько попыток потребуется пользователю на ввод правильного пароля). Циклы for относятся к первой категории. Они выполняются заранее известное число раз. Вот пример:
...
int z[3];
//Заполняем элементы массива.
for(int i=0; i<3; i++){
z[i]=i;
}
В этом примере мы заполняем элементы массива соответствующими числами. После ключевого слова for мы пишем в круглых скобках параметры для цикла (обратите внимание, что после for обязательно должны идти общие круглые скобки). Параметры для цикла делятся на три части, которые мы разделяем точкой с зяпятой. Первая часть - это задание начального значения для переменой цикла. В нашем примере мы переменной i присваиваем значение 0 (но можно и любое другое). Вторая часть - это условие продолжения цикла. Если оно истинно, то цикл продолжает выполнение. Как только оно станет ложным, цикл прекратится. Третья часть - это изменение переменной цикла. Чаще всего переменная цикла изменяется на 1. i++ как раз и увеличивает i на 1 (можно было записать и так: i=i+1 - только так писать дольше). Обратите внимание, что переменную i для цикла мы объявили прямо внутри цикла:
...
for(int i=0; ...){
...
Так часто и делают. Но, разумеется, i можно объявить и заранее:
int i;
...
for(i=0; ...){
...
Циклы for часто используются для перебора всех элементов массива. Вот так можно перебрать элементы двумерного массива:
int z[3][2];
//Заполняем элементы массива.
for(int i=0; i<3; i++){
for(int j=0; j<2; j++){
z[i][j]=0;
}
}
В цикле может быть и несколько переменных цикла. Вот пример:
int n=0;
for(int i=0, int j=0; i<3, j<2; i++, j++){
n++;
}
Этот цикл выполнится 2 раза и n по выходе из цикла будет равно 2. Синтаксис у такого цикла такой - имеются те же три части, между которыми пишем точку с запятой. Внутри каждой части в качестве разделителя пишем запятую. Цикл прекращается, если хотя бы одно из условий второй части (у нас это i<3, j<2;) окажется ложным.

Часть 4. Первая программа

Вот, наконец-то напишем первую программу. Вот ее текст:
#include
void main(){
cout<<"Hello World!\n";
}
Эта программа после компиляции и запуска выведет на экран надпись "Hello World!". Разберем текст программы. Начинаем ее со строчки
#include
Это так называемая директива препроцессора. Все директивы препроцессора начинаются с символа #. Конкретно директива include нужна для включения некоторого файла в вашу программу. Тут мы включаем файл iostream.h. Он нужен для того, чтобы мы в нашей программе могли что-ниюудь вводить с клавиатуры или выводить на экран. Этот include пишется почти всегда. После директив препроцессора точка с запятой не ставится. Далее в программе идет функция main. Функция с таким именем всегда должна присутствовать в любой консольной программе на C/C++ (причем только одна). Именно с нее (а не с первой строчки) начинается выполнение программы. Перед именем функции мы пишем тип возвращаемого значения (void означает, что функция ничего не возвращает - это аналог процедур в других языках программирования). После имени функции обязательно пишем круглые скобки. В них мы пишем парметры (если они есть). В нашем случае параметров нет. Тело функции пишем в фигурных скобках. В нашем примере мы в теле пишем
...
cout<<"Hello World!\n";
...
cout - это экран монитора (точнее, стандартное устройство для консольного вывода (парвая буква c - от слова console, out - вывод)). На консоль (экран) мы отправляем строку "Hello World!". Обратите внимание, куда передается наше строка (<< - так как она передается влево, на консоль). Не путайте - так как символ >> тоже существует и используется для консольного ввода. В строке внутри кавычек мы видим символы \n. Это переход на новую строку. Сами символы \n печататься не будут. Строки в C/C++ заключаются в двойные кавычки (в отличие от переменных типа char, значения для которых заключаем в одинарные кавычки). В C/C++ любой оператор заканчивается на точку с запятой. Точка с запятой - это часть оператора, а не разделитель между операторами, как, например, в Delphi.

Часть 5. Циклы while

Циклы while, в отличие от циклов for, предназначены для ситуаций, когда заранее неизвестно, сколько раз цикл должен выполнится. Циклы while делятся на 2 типа: while и do-while. Принципиальная разница между ними такая - while может не выполнится ни одного раза, do-while выполняется по крайней мере 1 раз. Так что надо смотреть по задаче - если наше действие точно должно один раз выполнится (например при запросе у пользователя пароля), то выбираем do-while. А вот и конкретный синтаксис:
while(a>0){
...//что-то делаем
};
Этот цикл будет выполятся до тех пор, пока a>0. Как только условие в крулых скобках станет ложным, цикл прекратит свою работу. Если же a будет сразу меньше или равно нулю, то цикл вообще ни разу не выполнится. Пример цикла do-while:
int password;
do{
cout<<"\nEnter password";
cin>>password; //Ввод пользователем пароля.
}while(password!=123);
Этот цикл будет выполнятся до тех пор, пока пользователь не введет 123 в качестве пароля. Т. е. его условие продолжения такое же, как у while - пока условие в скобках истинно, цикл продолжает работу. Обратите внимание, что после слова while условие продолжения цикла мы пишем в общих круглых скобках. Также обратите внимание, что переменные, влияющие на истинность условия, как-то внутри цикла должны меняться - иначе мы можем оказаться в бесконечном цикле:
int a = 5;
while(a>0)
{
cout<<"*";//Бесконечный цикл.
}
Здесь всегда a больше 0 и из цикла мы никогда не выйдем.

Часть 6. Директивы препроцессора

Мы уже сталкивались с одной директивой препроцессора в части 4. Сейчас мы обсудим, что такое. До компиляция (т. е. превращение в машинные коды) вашей программы происходят некоторые действия - а именно сначала выполняются так называемые директивы препроцессора, а уже потом - непосредственно компиляция. Директивы препроцессора могут, например, включать в файл вашей программы другие файлы (это мы делаем с помощью директивы #include), определять некоторые константы (директива #define) и многое другое. Важно понимать, что все директивы препроцессора выполняются до этапа компиляции. После выполнения директив препроцессора текст вашей программы будет изменен (не в исходном файле, конечно - там все как было, так и останется). Перед любой директивой препрцессора пишется знак #. Давайте немного приоткроем покров над тайной директив препроцессора на маленьком примере. Этот пример будет специфичен для Visual C++, но это не должно нас особенно тревожить - сейчас нам важно просто понять, как это все работает. Итак, создайте на Visual C++ новый проект для консольного приложения . Для файла *.cpp задайте имя test.cpp. В качестве текста программы введите
#include "test2.h"
#define pi 3.14
void main()
{
float z=2*pi;
}
Пока текст нас не слишком должен волновать. Если не все понимаете в тексте - не беда. Принцип здесь такой - #include влючает указанный файл в наш файл. У нас это файл test2.h. Создайте его (например в Блокноте) в той же папке, где находятся все остальные файлы вашего проекта. В нем напечатайте следующий текст (на самом деле можно напечатать все что угодно - это не принципиально):
struct v{
int x, y;
};
Еще одна директива препроцессора в нашей программе - это #define. Она просто пределяет константу pi, которую мы парой строчек ниже используем. Теперь для просмотра того, что получается после выполнения директив препроцессора, измените настройки нашего проекта. Нажимайте Alt+F7 (или меню Project и далее Settings) и переходим на вкладку C/C++. В ней меняем содержимое окошка Project Options:

Из этого окошка все удалите, и напечатайте там
/MLd /Fo"Debug/" /P
Пока мы это обсуждать не будем, отметим только, что с такими параметрами вы получите в папке проекта файл с результатом работы препроцессора. Закройте окно настроек нажав на OK. Компилируем программу (клавиша F7). В папке с файлами проекта появится файл test.i со следующим текстом:
#line 1 "D:\\_programming\\cpp\\test\\test.cpp"
#line 1 "D:\\_programming\\cpp\\test\\test2.h"
struct v{
int x, y;
};
#line 2 "D:\\_programming\\cpp\\test\\test.cpp"

void main()
{
float z=2*3.14;
}
Как вы видите, препроцессор поработал - вставил файл test2.h в наш файл и заменил pi на значение константы:
...
float z=2*3.14;

Так что работу препроцессера мы немного посмотрели.

Часть 7. Константы

Константа - это понятное обзначения для некоторой величины, которая не должна менятся в программе. Например, вместо 3.1415926 в программе удобнее писать что-то типа pi. Есть 2 способа объявления констант - через директиву препроцессора #define и через ключевое слово const. Вот пример использования в программе констаны, объявленной через директиву #define:
#include
#define SIZE 10
void main()
{
int z[SIZE];
for(int i=0; i {
z[i]=i;
}
int sum=0;
for(i=0; i {
sum+=z[i];
}
cout< }
А вот пример использования в программе константы, объявленной с помощью ключевого слова const:
#include
const int size = 10;
void main()
{
int z[size];
for(int i=0; i {
z[i]=i;
}
int sum=0;
for(i=0; i {
sum+=z[i];
}
cout< }
Использование констант сильно упрощает процесс изменения в программе. Если вам надо увеличить размер массива в приведенных примерах, то вы просто изменяете константу. Обратите внимание, что при объявлении массива таким способом:
...
int z[size];
...
size должна быть объявлена именно как константа. Если вы просто объявите size как целое, то компилятор выдаст ошибку.

Часть 8. Структуры

Структуры предназначены для хранения в одном месте различных данных, которые относятся к одному понятию. Скажем, данные для книги могут быть следующие: автор, название, количество страниц и т. п. И эти данные удобнее хранить не отдельно, а в одном месте. Вот пример объвления и использования структур:
#include
struct vector
{
//Координаты x и y вектора.
float x;
float y;
};
void main()
{
//Использование структуры vector.
vector d;
d.x=2;
d.y=-2.5;
}
Как вы видите, для объявления структуры используется ключевое слово struct. Для доступа к полям внутри структуры используется оператор точка (.):
...
d.x=2;

Обратите внимание, что после закрывающей фигурной скобки при объявлении структуры надо обязательно ставить точку с запятой:
struct vector
{
...
};
Без нее компилятор выдаст сообщение об ошибке. Внутри структур могут быть функции. Вот так может выглядеть наша структура с функциями:
struct vector
{
float x;
float y;
//Функция для записи x и y в вектор.
void SetVector(float x1, float y1){
x=x1;
y=y1;
}
//Функция для вывода вектора на консоль.
void ShowVector(){
cout<<"x="< }
};
А вот так функции можно использовать:
vector d;
...
d.SetVector(5, 3);
d.ShowVector(); //Выведется "x=5, y=3".
Напоследок отметим, что развитием структур являются классы. Их мы рассмотрим на последующих занятих.

Часть 9. Функции

Функция представляет из себя отдельный кусок кода, который вы можете многократно использовать. Каждая функция имеет имя и может возвращать значение. Написав функцию один раз, вы можете использовать ее столько раз, сколько надо - для это мы вызываем ее по имени. Вот пример:
//Объявление функции.
int sum(int a, int b)
{
return a+b;
}
void main()
{
//Вызов функции.
cout< }
Указанный фрагмент выведет, естественно, 8. В нашем фрагменте мы объявили функцию sum, которая принимает два параметра целого типа - a и b. Обратите внимание, как мы пишем параметры. Во-первых, в круглых скобках и через запятую:
int sum(int a, int b)
...
Круглые скобки тут надо писать, даже если у функции нет вообще параметров:
int sum()
...
и во-вторых, тип мы пишем перед каждым параметром - скажем такое объявление функции будет неправильным:
int sum(int a, b)
...
Значение, которая функция возвращает, мы пишем после return:
int sum(int a, int b){
...
return a+b;
}
Тип возвращаемого значения должен совпадать с типом функции - раз перед именем функции мы написали int, то и после return надо написать нечто типа int.

Часть 10. Рекурсивные функции

Функция может вызывать сама себя. Т. е. внутри функции мы используем ее саму. Вот классический пример - вычисление факториала (факториал n (обозначается как n!) - это произведение целых чисел от 1 до n. Например, 4!=24 (1*2*3*4)):
//Объявление функции.
int fact(int n)
{
if(n>1)
{
//Вызываем функцию из себя самой.
return n*fact(n-1);
}
else
{
//Факториал 1 равен 1.
return 1;
}
}
void main()
{
//Вызов функции.
cout< }
Обратите внимание, что функция внутри себя считается уже объявленной и ее можно использовать. Указанный фрагменты выведет, естественно, 120 (1*2*3*4*5).

Часть 11. Случайные числа

Для получения случайных чисел служит функция rand(). Параметров у нее нет. Она возвращает случайное число от 0 до значения констаны RAND_MAX. Как правило, эта константа равна 32767 (2 в 15-степени минус 1). Функция rand() (как и константа RAND_MAX) описана в файле stdlib.h, так что не забудьте подключить его:
#include
Вот пример использования функции rand():
int k;
k=rand();
Обратите внимание, что функция rand() будет постоянно возвращать одну и ту же последовательность случайных чисел. Это очень удобно на этапе отладки программы - если программа выдает ошибку, то эту ошибку легче воспроизвести при одних и тех же случайных числах. Реальная же программа должна, как правило, возвращать разные последовательности случайных чисел. Это делаем через функцию srand, которая принимает целый параметр, определяющий, какая конкретно последовательность случайных чисел у нас будет выдаваться функцией rand. Функцию srand достаточно вызвать только один раз в начале программы. Правда, в srand мы должны в качестве параметра подставить случайное число, но его можно получить, например, из текущего времени. Вот пример:
#include
...
srand((unsigned)time(NULL));
cout<

Часть 12. Встраиваемые (inline) функции

При компиляции тело функции не повторяется - т. е. при первом приближении оно имеется только в одном месте программы, и при вызове функции происходит переход на тело функции, которая и выполняется. При этом есть как плюсы, так и минуся. Плюс тот, что размер exe-файла получается не такой большой (функция-то занимает место только один раз), а минус - то, что программа работает несколько медленнее, так как тратится дополнительное время на переход к телу функции. Встраиваемые (inline) функции как раз и решают эту проблему. Оформляется такая функция как и обычная, только с ключевым словом inline. Но при компиляции тело функции подставляется во все места ее вызова. Минусы и плюсы тут меняются местами по сравнению с обычной функцией: вызов такой функции идет быстрее, а место exe-файл занимает больше. Вот пример:
...
//Встраиваемая функция.
inline int f(int a, int b)
{
return a*b;
}
void main()
{
//Вызов функции.
cout< cout< }
Надо сказать, что разные компиляторы по-разному работают с inline-функциями. Если компилятор не может сделать функцию встраиваемой, то он делает ее обычной. Например, такое может случится с рекурсивной функцией.

Часть 13. Ссылки

Когда мы передаем в функцию параметр, то он передается по значению. Это означает, что мы передаем в функцию копию и что изменения этого параметра внутри функции никак не повлияют на сам оригинал. Вот поясняющий пример:
#include
void f(int a)
{
a++; //Увеличиваем a на 1.
}
void main()
{
int k=20;
f(k);
cout< }
Тут мы внутри функции изменяем параметр на 1, но в функции main переменная k как имела значение 20, так и будет иметь. Параметры можно передавать и по ссылке. Это означает, что иы передаем в функцию сам оригинал переменной. Вот пример:
...
void f(int &a)
{
a++; //Увеличиваем a на 1.
}
void main()
{
int k=20;
f(k);
cout< }
В этом примере в функцию f передается оригинал переменной, и в функции main переменная k будет изменена. Это мы достигаем передачей ссылки на переменную:
...
void f(int &a)
{
...
Как вы видите, для передачи по ссылке мы используем знак амперсанда (&).

Часть 14. Адрес переменной

Операционная система Windows выделяет каждой программе 4 Гб адресного пространства. В реальности, конечно, такой оперативной памяти нет (хотя кто знает, что будет через пару-тройку лет ;)), но каждая программа искренне думает, что у нее есть столько места. Каждый байт адресного пространства имеет свой адрес. Адрес - это просто некоторое число. В Windows адрес выглядит приблизительно так: 0x0D56FF23. Тут префикс 0x означает что это число в шестнадцатеричном виде. Цифры шестнадцатеричного числа - это обычные числа от 0 до 9 и буквы A, B, C, D, E, F. Обратите внимание, что в адресе 8 знаков (так и должно быть, так как у каждой программы 4 Гб адресного пространства). Рассмотрим подробнее, что происходит, когда вы пишете в вашей программе что-то вроде
int z;
В этом случае в адресном пространстве вашей программы несколько байт (а именно столько, сколько надо на хранение одного целого - скорей всего это будет 4 байта) получают имя z. И это очень удобно - запись в эти ячейки идет не по их адресу (который выглядит как-то вроде 0x00FD240A) а по удобному имени z. Эти байты выделяются в определенном месте адресного пространства. Адрес первого байта нашего числа z будет начальным адресом все переменной z. Адрес можно получить непосредственно. Для этого служит оператор взятия адреса & (называется амперсанд). Вот пример:
int z;
cout<<&z; //Выводим на экран адрес переменной z.
Указаный фрагмент выведет что-то вроде 0x0012FF7C. Вот еще пример:
int z[3]; //Массив
cout< Тут выведется адрес начала массива (т. е. адрес его нулевого элемента). Таким образом имя массива - это адрес его начала.

Часть 15. Указатели

Указатель - одно из важных понятий языка C/C++. Начинающие программисты поначалу путаются, но со временем все должно встать на свои места. Итак, каждая переменная имеет свой адрес в адресном пространстве. Так вот, указатель - это переменная, которая хранит адрес другой переменной. Т. е. если в переменной обычного типа хранится, например, целое число, то в переменной-указателе может храниться адрес переменой, в котрой хранится целое число. Все это справедливо, разумеется, не только для целого типа, но и любого другого. Указатели различаются по типам. Например, указатель на целое может хранить адрес переменной целого типа, а указатель на тип float - адрес переменной типа float. Указатель на определенный тип объявляем так: сначала пишем этот тип, потом пишем звездочку и затем произвольное имя переменной. Пример:
int * p1; // Указатель на целое.
bool * p2; // Указатель на тип bool.
Так же как и для переменных обычного типа для переменных типа указатель мы при объявлении имеем в такой переменной мусор - т. е. некотрый непонятный адрес. Существует два способа записи инициализации указателя - записать в него адрес существующей переменной соответствующего типа или выделить новый участок памяти через ключевое слово new. Вот пример на первый способ:
int z=20;
int *p=&z;
Тут мы в указатель p записали адрес переменной z. А вот пример на второй способ инициалиазации указателя - через ключевое слово new:
int *p=new int;
В этом случае мы говорим, что память у нас выделена динамически. Синоним этого - память выделена в куче (heap). В противоположность этому память для переменных обычного типа (не указателей) выделяется в стеке. И в первом, и во втором способах в переменной p будет храниться указатель (адрес) целого типа. Для того, чтобы через этот адрес работать с тем местом, на котрое он указывает (т. е. в нашем случае с некоторым целым числом), мы используем так называемое разыменование указателя. Вот пример:
...
*p=123; //Записываем 123 в место, на которое указывает указатель p.
cout< cout<<*p<<"\n"; //Выведется 123;
Т. е. для доступа к тому месту, на которое указывает указатель, мы перед его именем добавляем звездочку. Таким образом по сути разыменование указателя - это доступ к тому месту на которое указатель указывает. Для указателей существует некий аналог нуля - это значение NULL. Вот пример:
int *p=NULL;
На самом деле NULL определена как 0, поэтому в большинстве способов можно писать 0 вместо NULL. Пока это было краткое знакомство с указателями. Подробности - в следующих уроках.

Часть 16. Оператор sizeof

Оператор sizeof позволяет выяснить, сколько байт занимает тот или иной тип. В качестве параметра он принимает или название типа, или переменную соответствующего типа. Вот пример:
int z;
cout< cout< Параметр может быть не только встроенным типом. Пример со структурой:
struct vector
{
float x;
float y;
};
void main()
{
vector s;
cout< }
Пример выведет 8, так как float занимает 4 байта и в нашей структуре 2 переменной типа float.

Часть 17. Комментарии

Комментарии - это некоторые пояснения, которые программист пишет сам для себя (чтобы потом не пришлось мучительно долго вспоминать, что делает та или иная функция или для чего нужна та или иная переменная). При компиляции комментарии игнорируются и, например, на размер exe-файла никак не влияют. Использование комментариев - эо хороший стиль в программировании. Комментарии в C++ бывают двух видов - однострочные и многострочные. Пример однострочного комментария:
int fig; //Количество фигур.
Однострочный комментарий может занимать как строчку целиком, так и часть строки (до конца строки). Началом однострочного комментария служит знак //. Пример многострочного комментария:
/*
Координаты точки.
*/
int x;
int y;
Границами многострочного комментария служат знаки /* и */. Кроме своего прямого предназначения, многострочные комментарии используются для времменного исключения некоторого куска в программе.

Часть 18. Параметры командной строки

В программу могут передаваться параметры командной строки. Несколько примеров таких программ - это команда ping (в качестве параметра выступает ip-адрес компьютера, с которым вы хотите проверить связь), команда copy (в качестве параметра выступают имя компируемого файла и новое местоположение и имя). Для работы с параметрами командной строки мы должны добавить два параметра в функцию main. Первый параметр задает общее количество передаваемых в программу параметров (при этом имя самого exe-файла тоже считается параметром), второй - сами параметры. Вот пример функции, которая выведет все свои параметры командной строки:
#include
void main(int argc, char* argv[])
{
for(int i=0; i {
//Выводим имя exe-файла
//и все параметры командной строки.
cout< }
}
Тут первый параметр: argc - это общее количество параметров. При простом запуске программы (например, простым щелчком на exe-файле) он будет равен 1. Второй параметр представляет из себя массив типа char*. Тип char* - это указатели на символ, который интерпретируется как строка. Нулевой элемент в этом массиве строк - это имя самого exe-файла, первый - это первый передаваемый параметр, второй - второй передаваемый параметр (разумеется, если эти параметры вообще есть). Откомпилируем и запустим нашу программу из командной строки с параметрами. Результат будет приблизительно такой:

В средах разработки часто существует возможность задать параметры командной строки в самой IDE. Вот так, например, это делается в Visual C++.NET. Из контесктного меню для проекта выбираем Properties:

затем в появившемся окне Property Pages в разделе Debugging задаем Command Arguments:

Часть 19. Преобразование типов

Преобразование типов - это приведение (превращение) одного типа в другой. Такое преобразование созможно далеко не всегда. А иногда в нем вообще нет особой необходимости - например, когда вы присваиваете переменной типа float значение переменной типа int - тут нет никакой потери точности, так что компилятор даже не выдаст вам предупреждения. А вот, например, обратный пример:
...
int a;
float b=2.78;
...
a=b; //Потеря точности!
Тут мы в переменную типа int записываем значение переменной типа float. Синтаксической ошибки не будет, но скорей всего компилятор выдась предупреждение о возможной потери точности. Для того, чтобы компилятор не ругался, мы сделаем преобразование типа float к типу int. Вот так:
...
a=(int)b;
...
Этот случай достаточно очевидный - мы преобразуем один числовой тип к другому. А вот так, например, можно преобразовать тип char к типу int или наоборот:
...
char ch='A';
//Выведется 65 - код символа 'A'.
cout<<(int)ch;

int a=7;
//Раздастся звонок (код 7).
cout<<(char)a;
...
На самом деле такое преобразование будет возможно, так как char - это тоже целочисленный тип как и int.

Часть 20. Работаем со строками

Вообще говоря в C/C++ нет строкового типа. Его роль выполняет либо указатель на char, либо массив char'ов. Для работы с такими строками в C++ есть несколько функций, тиена которых начинаются на str. Вот пример их использования:
#include
#include
void main()
{
char* ch="Roman";
char ch1[30];
//Показывем длину строки
cout< //Копируем строку
strcpy(ch1, ch);
cout< //Длина скопированной строки такая же, как и у старой
cout< //Сравнение строк
if(strcmp(ch, "Roma")==0)
{
cout<<"Strings are equal\n";
}
else
{
cout<<"Strings are not equal\n";
}
//Конкатенация (сложение) строк
strcpy(ch1, "Roman");
strcat(ch1, " Alexeev");
//Выведется "Roman Alexeev"
cout< }
Для использования таких функций мы должны написать соответствующий include:
...
#include
...
Пару слов следует сказать о функции strcmp. Она возвращает ноль, если строки равны; отрицательное число, если строка, задаваемая первым параметром, расположена в алфавитном порядке раньше строки, задаваемой вторым параметром; и положительное число, если первая строка расположена в алфавитном порядке дальше, чем вторая.