1. Fortran (В 1954 году компания IBM создала язык Fortran (formula translator) , его основу составляли арифметические операторы мат. выражений. Программировать на нем было не просто.)

COBOL (был изобретен в конце 1959 года. Этот язык был ориентирован на задачи бизнеса, также был аппаратно независим)

АЛГОЛ (Изобретен в 1958 году, это алгометрический язык программирования , в нем была доведена до завершения сама концепция операторных алгометрических языков программирования)

BASIC (. Сначала не имел ни кампилятора ни интерпритатора , они появились только в 1975 году. Самым популярным был М-BASIC – первый успех Microsoft)

PASCAL (Создан в 1970 году, был придуман для обучения студентов)

C++ (Разработан в 1971 году, главные преимущества – скорость и удобство, центральная идея – указатели)

2. Программа на языке С++ состоит из директив препроцессора, указаний компилятору, объявлений переменных и/или констант, объявлений и определений функций.

  Язык Си – компилирующего типа. Текст программы на Си, для получения объектного модуля обрабатывается компилятором, причем компиляция выполняется в два прохода. При первом проходе обрабатываются строки директивы, начинающиеся со знака #, при втором - транслируется текст программы и создается объектный (машинный) код. Для получения загрузочного модуля необходимо подсоединить к нему соответствующие библиотечные модули.

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

Типы данных: целый ( int , short , long, unsigned int). Вещественный : ( double , float) char- символьный, bool- логический

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

int k; // это переменная целого типа int

Инициализация переменных double a=3

В языке C++ есть 2 способа задания констант:

1. #define PI 3.14

2. const double PI=3.14;

5. Описание объектов для управления вводом-выводом содержится в дерективе предпроцессора <iostream>.

Операторы ввода вывода:

Cout – оператор вывода

<< - вывод в поток

Endl- перевод на новую строку

Cin – оператор ввода

>> - операция потокового ввода

Форматный вывод:

Int a=5, b=2;

Cout <<”a/b=”<<endl;

…………………………..

2-будет ответом т.к целый тип данных

Float c=5, d=2;

Cout<<”c/d=”<<endl;

……………………………………

2,5 будет ответом т.к. вещественный тип данных

Cout<<a%b<<endl;

……………………………

Ответом будет 1 т.к. это остаток от деления 5/2

Манипулятор	Назначение	Ввод/вывод
dec	Ввод/вывод данных в десятичной форме	ввод и вывод
endl	Вывод символа новой строки с передачей в поток всех данных из буфера	вывод
ends	Вывод нулевого символа	вывод
flush	Передача в поток содержи­мого буфера	вывод
hex	Ввод/вывод данных в шест­надцатиричной системе	ввод и вывод
oct	Ввод/вывод данных в восьме­ричной форме	ввод и вывод
resetiosflags(long f)	Сбрасывает флаги, указанные в f	ввод и вывод
setbase(int base)	Устанавливает базу счисле­ния равной параметру base	вывод
setfill(int ch)	Устанавливает символ заполнения равным ch	вывод
setiosflags(long f)	Устанавливает флаги, указанные в f	ввод и вывод
setprecision(int p)	Устанавливает число цифр после запятой	вывод
setw(int w)	Устанавливает ширину поля равной w	вывод
ws	Пропускает начальный символ-разделитель	ввод

6. Управляющие последовательности: Манипуляторы:

Символ	Описание
\r	возврат каретки в начало строки
\n	новая строка
\t	горизонтальная табуляция
\v	вертикальная табуляция
\»	двойные кавычки
\’	апостроф
\\	обратный слеш
\0	нулевой символ
\?	знак вопроса
\a	сигнал бипера (спикера) компьютера

7. Арифметические операции:

+ — сложение;- — вычитание;* — умножение;/ — деление;% — остаток от деления.

Операторы:

Составной оператор –  {...}

===================================

• Оператор обработки исключений

• try { <операторы> }

• catch (<объявление исключения>) { <операторы> }

• ...

• catch (<объявление исключения>) { <операторы> }

===================================

Условный оператор

if (<выражение>) <оператор 1> [else <оператор 2>]

Оператор-переключатель

switch (<выражение>)

{ case <константное выражение 1>: <операторы 1>

case <константное выражение 2>: <операторы 2>

...

case <константное выражение N>: <операторы N>

[default: <операторы>]

}

Оператор цикла с предусловием

while (<выражение>) <оператор>

Оператор цикла с постусловием

do <оператор> while <выражение>

Оператор пошагового цикла

for ([<начальное выражение>];

[<условное выражение>];

[<выражение приращения>])

<оператор>

Операции увеличения ++ и уменьшения --. Привести примеры реализации.

for(i=0; i<n; i++) –например проход по строке

for(i=0; i<n; --i)- например проход по строке с конца для поиска последнего отрицательного элемента

8. Операции сравнения: >, >= больше, больше равно; <, <= меньше , меньше равно; == равно ( не присваивание); != не равно; = присваивание

Логические операции:

Лог. Операция И: &&;Лог. Операция ИЛИ: ||; Лог. Операция Не: !

Примеры:

for(i=0; i<n; i++); if(f[i]==0); w++;

Приоритеты:

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

9. sqrt(a)	корень квадратный из а, причём а не отрицательно	sqrt(9.0)=3.0
   pow(a, b)	возведение  а в степень b	pow(2,3)=8
   exp(a)	вычисление экспоненты еа	exp(0)=1
   sin(a)	a задаётся в радианах
   cos(a)	a задаётся в радианах
   log(a)	натуральный логарифм a(основанием является экспонента)	log(1.0)=0.0

Double x,y;

Cout<<”x=”;

Cin>>x;

Y=pow(x,3);

Cout<<”y=”<<y<<endl;

10. Структу́рное программи́рование — методология разработки программного обеспечения, в основе которой лежит представление программы в виде иерархической структуры блоков.

Одиночный выбор:

For(i=0; i<n; i++)

If(f[i]==0)

Break;

Двойной выбор:

For(i=0; i<n; i++)

If(f[i]==0)

Break;

Else

K++;

Множественный выбор (switch):

// форма записи оператора множественного выбора switch

switch (/*переменная или выражение*/)

 {

 case /*константное выражение1/*:

 {

 /*группа операторов*/;

 break;

 }

 case /*константное выражение2*/:

 {

 /*группа операторов*/;

 break;

 }

 //.    .    .

 default:

                {

                 /*группа операторов*/;

                }

 }

На начальном этапе анализируется выражение или переменная. После чего осуществляется переход к той ветви программы, для которой значение переменной или выражения совпадает с указанным константным выражением. Далее выполняется оператор или группа операторов пока не встретится зарезервированное слово break или закрывающая фигурная скобочка. Если значение переменной или выражения не совпадает ни с одним константным выражением, то передается управление ветви программы содержащей зарезервированное слово default. После чего выполняется оператор или группа операторов данной ветви. Сейчас рассмотрим задачу с использованием оператора выбора switch.

11. Как уже было отмечено выше, любую программу можно составить только из структур трех типов: следования, ветвления и цикла (это базовые конструкции).

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

• Ветвление задает выполнение либо одного, либо другого оператора в зависимости от выполнения какого-либо условия.

• Цикл задает многократное выполнение оператора.

switch

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

Множественный выбор (switch):

// форма записи оператора множественного выбора switch

switch (/*переменная или выражение*/)

{

case /*константное выражение1/*:

{

 /*группа операторов*/;

break;

}

case /*константное выражение2*/:

{

 /*группа операторов*/;

break;

}

 //.    .    .

default:

{

 /*группа операторов*/;

}

}

=========или==============================================================================================================================

{

Case 1;

Case 2;

Do_something(x,a);

Break;

Case 3;

Do_something_else(a);

Case 4;

Do_nice_things(a,x);

Break;

Default;

Do_something_by_default;

}

13. Есть два типа циклов: типа «пока» и типа «n-раз».

14. Пример: увеличить число пока оно не станет равно 5ти.

15. Int i=1;

16. While (i<5)

17. { cout<<i<<” “;

18. I++;

19. На экран выведет «1;2;3;4;»

20. Int i=1;

21. Do

22. { i++

23. Cout<<i<<” ”;

24. } while(i<0);//пост проверка

25. Такой цикл выполнится 1 раз

26. На экран выведет «2»

28. С пред условием(While)

29. Int i=1;

30. While (i<5)

31. { cout<<i<<” “;

32. I++;

33. На экран выведет «1;2;3;4;»

34. С пост условием(do … While)

35. Int i=1;

36. Do

37. { i++

38. Cout<<i<<” ”;

39. } while(i<0);//пост проверка

40. Такой цикл выполнится 1 раз

41. На экран выведет «2»

42. Различие состоит в том что на экран будет выводиться разное.

43. 

46. #include <iostream>

47.  

48. using namespace std;

49.  

50. int main()

51. {

52.     int a, b, c, d, e, f;

53.     cout << "Enter a: ";

54.     cin >> a;

55.     cout << "Enter b: ";

56.     cin >> b;

57.     cout << "Enter c: ";

58.     cin >> c;

59.     cout << "Enter d: ";

60.     cin >> d;

61.     cout << "Enter e: ";

62.     cin >> e;

63.     cout << "Enter f: ";

64.     cin >> f;

65.     int C(0);

66.     while(true)

67.     {

68.         C++;

69.  

70.         if(C++ > 9000)

71.         {

72.             break;

73.         }

74.         else

75.         {

76.            cout << C << "\n";

77.         }

78.     }

79.     cout << "a: " << a << " b: " << b << " c: " << c << " d: " << d << " e: " << e << " f: " << f << endl;

80.     return 0;

81. }

82. 

83. Int n=0

84. For(int i=0; i<3; i++){

85. For(int j=0; j<5; j++){

86. N=n+2;

87. } }

88. Здесь внешний цикл это тот, в котором перемещается I . Внутренний цикл с переменной j. сначала , при i=0, j пройдет по всем своим значениям от 0 до 4. Потом I перейдет на 1, а j опять будет нарезать круги с 0 до 4, и так пока не закончится внешний цикл. Т .е. всего будет 15 итераций , а n в конце будет 30.

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

91. Задание: вычислить значение бесконечного выражения (прогрессии) с вводом с клавиатуры значения аргумента (х) и количества членов (N).

94. #include <cstdlib>

95. #include <iostream>

96. #include <cmath>

97. using namespace std;

98. int main(int argc, char *argv[])

99. {

100.     double a, b=1, c=sqrt(3.), y=0, x, N, t;

101.     cout << "x= ";

102.     cin >> x;

103.     cout << "N= ";

104.     cin >> N;

105.     a = cos(x);

106.     cout<<a;

107.     for (int i=1; i<=N; i++)

108.         {

109.              y = ((a+b)/c) + y;

110.              b++;

111.              t=i%2;

112.              if (t==0)

113.              {

114.                       c=sqrt(3+c);

115.              }

116.              else

117.              {

118.                       c=sqrt(4+c);    

119.              }

120.         }

121.         cout << "y= " << y << endl;

122.                      

123.     system("PAUSE");

124.     return EXIT_SUCCESS;

125. }

127.  Пользовательская функция - Это функция, которая создана пользователем.

128. void swap (int x, int y){    int z = x;    x = y;    y = z;  }

129. Как вы, наверное, догадались - это пользовательская функция, которая меняет местами значения у элементов

130. void GetError (){    pritnf ("Ошибка\n"); }

131. Пользовательская функция, выбрасывающая сообщение об ошибке

132. int max (int a, int b, int c){    if (a > b && a > c)       return a;    if (b > a && b > c)       return b;    if (c > a && c > b)        return c; }

133. Эта созданная пользовательская функция определяет наибольшее число из трех.

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

136. Передача по значению эквивалентна операции присвоения.

137. Адрес и ссылка используются в случае если нид получить от функции более одного результата.

138. Пример:

139. B=1;

140. Cout<<cube(b++)<<endl;

141. Cout<<b<<endl;

142. Выведется на экран:

143. 1

144. 2

145. Это соответствует выполнению операции присваивания x=b++;

147. Функция должна быть определена до того, как использована.

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

149. Тело функции – это блок, т.е. последовательность описаний переменных операторов, заключенных в фигурные скобки. Даже если функция не выполняет никаких действий тело функции должно присутствовать в определении. В этом случае тело функции будет состоять просто из скобок {}:void f(void){}

150. Определения функций не должны быть вложенными. В отличие от определений, прототипы – объявления функций могут быть вложенными в другие функции, главное чтобы прототип был прописан для вызова соотв. Функции.

151. Примеры объявления функций: int add (int, int) – это объявленная функция которая требует 2 аргумента типа int и возвращает величину типа int.

152. Определение функций maximum:

153. Int maximum (int x; int y; int z)

155. Параметры со значениями по умолчанию должны объявляться последними параметрами в списке. При вызове функции такие параметры можно не указывать – используется значение, заданное по умолчанию.

156. Пример:

157. Void repch (char ch=’-’, int k=60)

158. C++ разрешает такие вызовы функции

159. Repch();//выводится 60 минусов

160. Repch(+)//выводиться 60 плюсов

161. Repcj(‘=’52)//выводится 52 равно

162. Вызов функции считается корректным если не указывается самое правое параметры

164. Рекурсивная функция – это функция которая может вызвать саму себя.

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

166. Пример:факториал

167. Include’s

168. …………………..

169. Unsigned int factor(unsigned int)//прототип функции

170. Int man (void)

171. {

172. Unsigned unt n;// число факториал которого нид вычислить

173. Unsigned int F;//факториал чилса n

174. Cout<<”вычисление факториала:\n”;

175. Cout<<”введите число, факториал которого нид вычислить”;

176. Cin>>n;

177. F=factor(n);

178. Cout<<”факториал числа”<<n<<”равен”<<F;

179. Return 0;

180. }

181. {if(k==1)

182. Return 1;

183. Else

184. K*Factor(k-1);

185. Return 0’

187. Время жизни – это время существования переменной во время работы программы.

188. Глобальные переменные – ее имя видно с момента объявления.

189. За пределами функций имена объявленных внутри нее переменных не видны, т.е. имя переменной нельзя использовать вне тела функции . Говорят что область видимости локальных переменных – тело функции.

190. Пример статических функции:

191. Double average(double data)

192. { static double summa =0;// инициализация статических переменных при первом вызове.

193. Static int count=0;

194. Cout++;

195. Summa+=data;

196. Return summa/cout;// возврат нового среднего значения

197. }

198. Int main()

199. { double data=1, middle;

200. While (data)

201. {

202. Cout<<”введите число:”;

203. Cin>>data;

204. Middle=average(data);//выражение очередного среднего

205. Cout<<”среднее значение:”<<middle<<endl;

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

208.      #include<iostream>      using namespace std;      void swap(int a, int b)      {          int t;          t=b;          b=a;          a=t;      }      int main()      {          int p=3,q=5;          swap(p,q);          cout<<p<<" "<<q<<endl;          return 0;      }

209. При вызове функции swap создаются новые переменные a и b, им присваиваются значения 3 и 5. Эти переменные никак не связаны с переменными p и q и их изменение не изменяет значения p иq. Такой способ передачи параметров называется передачей параметров по значению.

210. void swap(int & a, int & b)

211. Амперсанды перед именем переменной означают, что эта переменная является не локальной переменной, а ссылкой на переменную, указанную в качестве параметра при вызове функции. Теперь при вызове swap(p,q) переменные a и b являются синонимами для переменных p и q, и изменение их значений влечет изменение значений p и q. А вот вызывать функцию в видеswap(3,5) уже нельзя, поскольку 3 и 5 — это константы, и сделать переменные синонимами констант нельзя.

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

214. Перегрузка функций позволяет вашим программам определять несколько функций с одним и тем же именем и типом возвращаемого значения. Например, следующая программа перегружает функцию с именемadd_values.

215. #include <iostream.h>

216. int add_values(int a,int b)

217. { return(a + b); )

218. int add_values (int a, int b, int c)

219. ( return(a + b + c); )

220. void main(void)

221. { cout << «200 + 801 = » << add_values(200, 801) << endl; cout << «100 + 201 + 700 = » << add_values(100, 201, 700) << endl; }

222. Как видите, программа определяет две функции с именами add_valuesПервая функция складывает два значения типа int, в то время как вторая складывает три значения. 

224. Массивы – это группа однородных данных, имеющих один и тот же тип и одно и тоже имя.

225. Объявление: ( тип_имя_кол-во. Элементов) int month [12] или double mas[32]

226. Инициализация: int mas[5]={1, 2, 3, 4, 5} или с клавиатуры. For(int i=0; i<12; ++i) Cin>>mas[i]

227. Обработка: Получение суммы элементов массива

228. Поиск максимума, минимума и др. задаваемых значений.

229. Сортировка массива.

230. Выполнение однотипных действий над всеми элементами массива.

231. Использование: Массивы используются для обработки большого количества однотипных данных.

233. Одномерный массив — массив, с одним параметром, характеризующим количество элементов одномерного массива. Фактически одномерный массив — это массив, у которого может быть только одна строка, и n-е количество столбцов. Столбцы в одномерном массиве — это элементы массива.

234. Индекс ячейки – это целое неотрицательное число, по которому можно обращаться к каждой ячейке массива и выполнять какие-либо действия над ней (ячейкой).

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

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

237. // массивы могут быть инициализированы при объявлении:

238. int a[16] = { 5, -12, -12, 9, 10, 0, -9, -12, -1, 23, 65, 64, 11, 43, 39, -15 }; // инициализация одномерного массива

239. В данном случае компилятор сам определит размер одномерного массива. Размер массива можно не указывать только при его инициализации, при обычном объявлении массива обязательно нужно указывать размер массива. Разработаем простую программу на обработку одномерного массива.

240. Int a[]={5,-12,-12,9,10,0,-9,-12,-1,23,65,64,11,43,39,-15};//инициализации массива без определения его размера.

242. Алгоритм пузырьковой сортировки – это довольно простой в реализации алгоритм для сортировки массивов. Можно встретить и другие названия: пузырьковая сортировка, Buble sortили сортировка простыми обменами – но все они будут обозночать один и тот же алгоритм. Назван так, потому что большее или меньшее значение “всплывает” (сдвигается) к краю массива после каждой итерации, это будет видно в примере.

243. Сложность этого алгоритма выражается формулой О(n^2) (n в степени 2). Алгоритм работает медленно с большими массивами, а поэтому малоэффективен и на практике используется редко, чаще всего в учебных целях. Для сортировки массивов на практике используют другие более быстрые алгоритмы, один из них –  QuickSort(быстрая сортировка). Функция для быстрой сортировки включена во многие стандартные библиотеки языков программирования, например в языке C функция qsort() из стандартной библиотеки.

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

246. Сортировка вставками (Insertion Sort) — это простой алгоритм сортировки. Суть его заключается в том что, на каждом шаге алгоритма мы берем один из элементов массива, находим позицию для вставки и вставляем. Стоит отметить что массив из 1-го элемента считается отсортированным. Словесное описание алгоритма звучит довольно сложно, но на деле это самая простая в реализации сортировка. Каждый из нас, не зависимо от рода деятельности, применял алгоритм сортировки, просто не осознавал это. Например когда сортировали купюры в кошельке — берем 100 рублей и смотрим — идут 10, 50 и 500 рублёвые купюры. Вот как раз между 50 и 500 и вставляем нашу сотню. Или приведу пример из всех книжек — игра в карточного «Дурака». Когда мы тянем карту из колоды, смотрим на наши разложенные по возрастанию карты и в зависимости от достоинства вытянутой карты помещаем карту в соответствующее место.

247. Нумерация элементов массива начинается с 0 и заканчивается n-1. 

248. for(int i=1;i<n;i++) for(int j=i;j>0 && x[j-1]>x[j];j--) // пока j>0 и элемент j-1 > j, x-массив int swap(x[j-1],x[j]); // меняем местами элементы j и j-1

249. Сортировка вставками имеет сложность n², количество сравнений вычисляется по формуле n*(n-1)/2.

250. Итак при n=100 количество перестановок равно 4950, а не 10000 если бы мы высчитывали по формуле n². Имейте это ввиду при выборе алгоритма сортировки.

253. Двумерные массивы в С++

254. Допустим, необходимо обработать некоторые данные из таблицы. В таблице есть две характеристики: количество строк и количество столбцов. Также и в двумерном массиве, кроме количества элементов массива, есть такие характеристики как, количество строк и количество столбцов двумерного массива. То есть, визуально, двумерный массив — это обычная таблица, со строками и столбцами. Фактически двумерный массив — это одномерный массив одномерных массивов. Структура двумерного массива, с именем a, размером m на n показана ниже (см. Рисунок 4).

255. 

256. где, m — количество строк двумерного массива; n — количество столбцов двумерного массива; m * n — количество элементов массива.

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

• тип данных;

• имя массива.

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

259. Рассмотрим пример объявления двумерного массива. Допустим нам необходимо объявить двумерный массив, с количеством элементов, равным 15. В таком случае двумерный массив может иметь три строки и пять столбцов или пять строк и три столбца.

1 2	// пример объявление двумерного массива: int a[5][3];

• a — имя целочисленного массива

• число в первых квадратных скобках указывает количество строк двумерного массива, в данном случае их 5;

• число во вторых квадратных скобках указывает количество столбцов двумерного массива, в данном случае их 3.

1 2	// инициализация двумерного массива: int a[5][3] = { {4, 7, 8}, {9, 66, -1}, {5, -5, 0}, {3, -3, 30}, {1, 1, 1} };

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

269. Код программы на Visual C++ вода-вывода матрицы будет иметь примерно такой вид:

270. #include "stdafx.h" #include <iostream> using namespace std; int main() { setlocale (LC_ALL, "RUS"); int i,j,N,M,a[20][20]; cout<<"N="; //ввод количества строк cin>>N; cout<<"M="; //ввод количества столбцов cin>>M; cout<<"Input matrix A \n"; //цикл по переменной i, в которой перебираем строки матрицы for (i=0; i<N; i++) //цикл по переменной j, в котором перебираем элементы внутри строки for (j=0; j<M; j++) cin>>a[i][j]; //ввод очередного элемента матрицы cout<<"matrix A \n"; for (i=0; i<N; i++) { //цикл по переменной i, в котором перебираем строки матрицы for (j=0; j<M; j++) cout<<a[i][j]<<"\t"; //вывод очередного элемента матрицы cout<<endl; //переход на новую строку после вывода всех элементов строки } system("pause"); return 0; }

271. Теперь, давайте рассмотрим некоторые свойства матриц:

• если номер строки элемента совпадает с номером столбца  (i = j), это означает , что элемент лежит на главной диагонали матрицы;

• если номер строки превышает номер столбца (i > j), то элемент находиться ниже главной диагонали;

• если номер столбца больше номера строки (i < j), то элемент находиться выше главной диагонали;

• элемент лежит на побочной диагонали, если его индексы удовлетворяют равенству i+j+1=n;

• неравенство i+j+1<n характерно для элемента, находящегося выше побочной диагонали;

• соответственно, элементу, лежащему ниже побочной диагонали, соответствует выражение i+j+1>n.

272. Найти сумму элементов матрицы, лежащих выше главной диагонали 

273. #include "stdafx.h" #include <iostream> using namespace std; int main() { setlocale (LC_ALL, "RUS"); int S, i, j, N, M, a[20][20]; cout<<"N="; cin>>N; cout<<"M="; cin>>M; cout<<"Введите матрицу А \n"; for (i=0; i<N; i++) for (j=0; j<M; j++) cin>>a[i][j]; for (S=i=0; i<N; i++) for (j=0; j<M; j++) //если элемент лежит выше главной диагонали, то наращиваем сумму if (j>i) S+=a[i][j]; cout<<"S="<<S<<endl; system("pause"); return 0; }

275. Многомерные массивы

276. В языке Си могут быть также объявлены многомерные массивы. Отличие многомерного массива от одномерного состоит в том, что в одномерном массиве положение элемента определяется одним индексом, а в многомерном — несколькими. Примером многомерного массива является матрица.

277. Общая форма объявления многомерного массива

278. тип имя[размерность1][размерность2]...[размерностьm];

279. Многомерные массивы задаются указанием каждого измерения в квадратных скобках, например, оператор

280. int matr [6][8];

281. задает описание двумерного массива из 6 строк и 8 столбцов. В памяти такой массив располагается в последовательных ячейках построчно. Многомерные массивы размещаются так, что при переходе к следующему элементу быстрее всего изменяется последний индекс. Для доступа к элементу многомерного массива указываются все его индексы, например, matr[i][j], или более экзотическим способом: *(matr[i]+j) или *(*(matr+i)+j). Это возможно, поскольку matr[i] является адресом начала i-й строки массива.

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

283. int mass2 [][2] = { {1, 1}, {0, 2}, {1, 0} }: int mass2 [3][2] = {1, 1, 0, 2, 1, 0}

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

285. #include <stdio.h>

286. int main(){

287. const int nstr = 4, nstb = 5; // размерности массива

288. int b[nstr][nstb]; // описание массива

289. int i, j;

290. for (i = 0; i<nstr; i++) // ввод массива

291. for (j = 0; j<nstb; j++) scanf("%d", &b[i][j]);

292. int istr = -1, MaxKol = 0;

293. for (i = 0; i<nstr; i++){ // просмотр массива по строкам

294. int Коl = 0:

295. for (j = 0; j<nstb; j++) if (b[i][j] == 0) Kol++;

296. if (Ko1 > MaxKol) {istr = i ; MaxKol = Kol;}

297. }

298. printf(" Исходный массив:\n");

299. for (i = 0; i<nstr; i++){

300. for (j = 0; j<nstb; j++) printf("%d ", b[i][j]);

301. printf ("\n");}

302. if (istr == -1) printf("Нулевых элементов нет");

303. else printf("Hoмep строки: %d", istr);

304. return 0;

305. }

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

307. #include "stdafx.h"

308. #include <iostream>

309. using namespace std;

310. int main()

311. {

312. int i, j, n, m, mi(0), mj(0);

313. cout<<"Vvedite n: ";

314. cin>>n;

315. cout<<"Vvedite m: ";

316. cin>>m;

317. cout<<"Vvedite massiv:";

318. int** mas = new int* [n];

319. for(i = 0; i < n; ++i)

320. {

321. mas[i] = new int [m];

322. for(j = 0; j < m; ++j)

323. cin>>mas[i][j];

324. }

325. for(i = 0; i < n; ++i)

326. for(j = 0; j < m; ++j)

327. if(mas[i][j] > mas[mi][mj])

328. mi = i, mj = j;

329. cout<<"Max - mas["<<mi<<"]["<<mj<<"] = "<<mas[mi][mj];

330. cin.get();

331. cin.get();

332. system ("pause");

333. return 0;

334. }

336. Функция ввода символов

337. Для ввода символов может использоваться функция

338. char getchar();

339. которая возвращает значение символа, введенного с клавиатуры.

340. Функция вывода символов

341. Для вывода символов может использоваться функция

342. char putchar(char);

343. которая возвращает значение выводимого символа и выводит на экран символ, переданный в качестве аргумента.

344. (пример)Посчитать количество введенных символов во введенной строке.

345. #include "stdafx.h"

346. #include <string>

347. #include <iostream>

348. using namespace std;

349. int _tmain(int argc, _TCHAR* argv[])

350. {

351. setlocale(LC_ALL, "");

352. char input[256];

353. cout<<"Введите строку: ";

354. cin>> input;

355. cout <<"Строка"<<input<<"содержится"<<strlen(input)<<"символов \n";

356. system ("pause");

357. return 0;

358. }

360. Объявление и инициализация строк.                 Строкой называется массив символов, который заканчивается пустым символом ‘\0’. Строка объявляется как обычный символьный массив, например,           

361.       char  s1[10];          

362.     char  *s2;              // указатель на строку Различие между указателями s1 и s2 заключается в том, что указатель s1 является именованной константой, а указатель s2 – переменной.             

363.     Строковые константы заключаются в двойные кавычки в отличие от символов, которые заключаются в одинарные кавычки. Например,                 “This is a string.” Длина строковой константы не может превышать 509 символов по стандарту..      При инициализации строк размерность массива лучше не указывать, это выполнит компилятор, подсчитав длину строки и добавив к ней единицу. Например,                 char  s1[ ] = “This is a string.”;       

364.      #include <string>  .  .  {  getline(cin,stroka);(ввод строки с клавы)  n=stroka.lenght(); (считает колл символов в строке)

366. Функции для работы со строками объявлены в заголовочном файле string.h. Приведем некоторые из них:

367. char *strcpy(char *dest, const char *src);

368. копирует второй аргумент в первый. Возвращает указатель на копию. Память для dest должна быть заранее зарезервирована.

369. char *strdup(const char *s);

370. копирует строку во вновь создаваемую функцией malloc() область памяти. Возвращает указатель на созданную копию или 0 при неудаче. Программист ответственен за освобождение памяти функцией free();

371. size_t strlen(const char *s);

372. подсчитывает размер строки. Возвращает количество символов строки без нулевого символа. Тип size_t определен в файле string.h и других заголовочных файлах как целое без знака: typedef unsigned size_t;

373. char *strcat(char *dest, const char *src);

374. присоединяет вторую строку к первой. Возвращает указатель на начало нарощенной строки.

375. char *strchr(const char *s, int c);

376. сканирует строку s в поисках первого вхождения заданного символа с. Нулевой символ можно искать наряду с другими. Возвращает указатель на найденный символ или 0, если символа нет.

377. char *strrchr(const char *s, int с);

378. то же, что strchr, но находит последнее вхождение символа с в строку s.

379. char *strstr(const char *s1, const char *s2);

380. находит первое вхождение подстроки s2 в строку s1. Возвращает указатель на место первого вхождения или 0, если такового нет.

381. int strcmp(const char *s1, const char*s2);

382. сравнивает две строки. Возвращает целое меньше нуля, если s1 < s2, равное нулю, если s1 == s2, и большее нуля, если s1 > s2.

383. char *strpbrk(const char *s1, const char *s2);

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

385. char *strtok(char *s1, const char *s2);

386. сканирует первую строку в поисках первого участка, не содержащего символов из s2.

387. strcpy() (от слова copy – копирование)

388. Реализуем копирование одной строки и её вставку на место другой строки.

390. #include <iostream>

391. using namespace std;

392. int main()

393. {

394. setlocale(LC_ALL, "rus");

395. char someText1[64] = "Сaйт purecodecpp.com!";

396. char someText2[] = "Основы С++";

397. cout << "Строка someText1 - \"" << someText1 << "\" \n";

398. cout << "Строка someText2 - \"" << someText2 << "\" \n\n";

399. int count = 0;

400. while (true) // запускаем бесконечный цикл

401. {

402. someText1[count] = someText2[count]; // копируем посимвольно

403. if (someText2[count] == '\0') // если нашли \0 у второй строки

404. {

405. break; // прерываем цикл

406. }

407. count++;

408. }

409. cout << "Строка someText1 после копирования someText2 -\n\"" << someText1 << "\" \n\n";

410. return 0;

411. }

413. char *s

414. char c

415. char *strchr (s,c)

416. поиск первого вхождения символа (с) в строке (s) В случаи удачного поиска возвращает указатель на место первого нахождения символа (с) а если не находит то возвращает NULL(пустой указатель)

417. char *s1,*s2

418. char *strstr(s1,s2)

419. функция ищет в строке s1 подстроку s2 и возвращает на нее указатель или NULL если не найдено

422. Функции сравнения строк.

423. Пример 1:

424. {char s1[]=”строчка”;

425. Char s2[]=”строчка”;

426. Cout<<”s1==s1->”<<setw(2)<<strcmp(s1,s1)<<endl;

427. Cout<<”s1<s2->”<<setw(2)<<strcmp(s1,s2)<<endl;

428. Cout<<”s2>s1->”<<setw(2)<<strcmp(s2,s1)<<endl;

429. System (“pause”);

430. Return 0;

431. функция конкатенации строк.

432. Конкатенация- Объединение строк.

433. {char str[100];

434. Strcpy(str,”эти”);

435. Strcpy (str,”строки”);

436. Strcpy (str,”объединены”);

437. Cout<<str<<endl;

438. Char *s1,*s2;

439. Char *strcat(s1,s2) //присоединяет к строке s1 строку s2

440. Char *s1,*s2;

441. Int n;

442. Char *strcat(s1,s2,n); // присоединяет n-символов строки s2 к строке s1.