Theory

Structures in C++

Example:

1 2 3 4 5 6 7

struct product { int weight; double price; } ;   product apple; product banana, melon;

struct product { int weight; double price; } ; product apple; product banana, melon;

This declares a structure type, called product, and defines it having two members: weight and price, each of a different fundamental type. This declaration creates a new type (product), which is then used to declare three objects (variables) of this type: apple, banana, and melon. Note how once product is declared, it is used just like any other type.
• Right at the end of the struct definition, and before the ending semicolon (;), the optional field object_names can be used to directly declare objects of the structure type. For example, the structure objects apple, banana, and melon can be declared at the moment the data structure type is defined:

1 2 3 4

struct product { int weight; double price; } apple, banana, melon;

struct product { int weight; double price; } apple, banana, melon;

In this case, where object_names are specified, the type name (product) becomes optional: struct requires either a type_name or at least one name in object_names, but not necessarily both.

Access to the objects’ members

1
2
3
4
5
6

apple.weight
apple.price
banana.weight
banana.price
melon.weight
melon.price

Pointers to structures

1
2
3
4
5
6
7

struct Product_t {
  int weight;
  double price;
} apple, banana, melon;
 
Product_t aproduct;
Product_t * pproduct;

 
pproduct = &aproduct;

//...
struct Product_t {
  int weight;
  double price;
} ;
 
int main ()
{
  string mystr;
 
  Product_t aproduct;
  Product_t * pproduct;
  pproduct = &aproduct;
 
  cout << "Enter weight: ";
  cin >> pproduct ->weight;
  cout << "Enter price: ";
  cin >> pproduct ->price;
 
  cout << "\nYou have entered:\n";
  cout << pproduct ->weight << " ";
  cout << pproduct ->price;
 
  return 0;
}

Tuples

Example:

#include <string>
#include <tuple> // std::tuple, std::get, std::tie, std::ignore
 
using namespace std;
 
int main()
{
  tuple<int, char, string> t {4, 'z', "C++"}; // the 1-st way of declaration
  auto x = make_tuple(4, 'z', "C++"); // the 2-d way of declaration
 
  auto s1 = get<2>(x);  // access element
  get<0>(t) = 20; // set to another value
  int i; char c; string s;
  tie(i, c, s) = t; // unpack elements
  tie(ignore, ignore, s) = t; //unpack (with ignore) 
}

Лабораторные работы

Lab 1:
Введите год работы Чехова под названием Три сестры:
1897
Работа Пушкина:
 Евгений Онегин 1823
Работа  Чехова:
 Три сестры 1897

✍ Алгоритм:

void printCars(Cars_t car);

Task 1:
Введите марку автомобиля:
>>audi
Введите цвет автомобиля:
>>grey
Введите год выпуска автомобиля:
>>1997
Информация:
audi grey 1997
bmw green 2009
suzuki white 2015
honda black 2019

Введите название игрушки:
>>cat
Введите возраст ребенка:
>>2
Краткая информация:
car 3
doll 4
crocodile 6
cat 2
Краткая информация по игрушкам для маленьких детей:
car 3
doll 4
cat 2

✍ Алгоритм:

// возвращает результат вычисления (double)
double printTourCost(Tours_t tour);

Task 2:
информация:
 Sweden: people 2, days 3, rate 155.5
 the price is 933
Norway: people 1, days 3, rate 265.5
 the price is 796.5
UK: people 2, days 4, rate 455.5
 the price is 3644

введите название: 
>>Matrix
введите год: 
>>1999

Краткая информация:
Matrix 1999
Titanic 1997

✍ Алгоритм:

void smallSalary(Employee_t* array, int n);

Task 3:
Информация:
Ivanov: бухгалтерия, t. 233-33-33, 28000 roubles
Petrov: ИТ-отдел, t. 233-33-34, 45000 roubles
Sidorov: клиентский отдел, t. 233-33-35, 25000 roubles

с зарплатой менее 30 000 рублей:
Ivanov
Sidorov

Теория

Шаблонные функции

• Шаблонная переменная объявляется началом класса или функции:

template <typename T> int max(T a, T b) { if (a > b) { return a; } return b; }

template <typename T> int max(T a, T b) { if (a > b) { return a; } return b; }

• Шаблонные переменные проверяются во время компиляции, что позволяет отлавливать ошибки перед запуском программы.

#include <iostream> using namespace std;   template <typename T> T max(T a, T b) { if (a > b) { return a; } return b; } int main() { cout << "max(3, 5): " << max(3, 5) << endl; // 5 cout << "max('a', 'd'): " << max('a', 'd') << endl; // d cout << "max(\"Hello\", \"World\"): " << max("Hello", "World") << endl; // Hello cout << "max(3, 5, 6): " << max(3, 5, 6) << endl; // error   return 0; }

#include <iostream> using namespace std; template <typename T> T max(T a, T b) { if (a > b) { return a; } return b; } int main() { cout << "max(3, 5): " << max(3, 5) << endl; // 5 cout << "max('a', 'd'): " << max('a', 'd') << endl; // d cout << "max(\"Hello\", \"World\"): " << max("Hello", "World") << endl; // Hello cout << "max(3, 5, 6): " << max(3, 5, 6) << endl; // error return 0; }

• Шаблонные функции определяют семейство функций.
• Объявлять их лучше в заголовочном файле, там, где и объявлены функции.

lib.cpp

#include "lib.h"

#include "lib.h"

lib.h

template<typename T> class My { My() { } T f(T a, T b); };   template<typename T> T My::f(T a, T b) { return a + b; }

template<typename T> class My { My() { } T f(T a, T b); }; template<typename T> T My::f(T a, T b) { return a + b; }

• Шаблонная функция сама по себе не является типом, или функцией, или какой-либо другой сущностью. Никакой код не генерируется из исходного файла, содержащего только определения шаблонов. Для того чтобы появился какой-либо код, должен быть создан экземпляр шаблона: аргументы шаблона должны быть определены таким образом, чтобы компилятор мог сгенерировать функцию.
• Явное определение экземпляра принудительно создает экземпляр функции или функции-члена, на которые они ссылаются. Он может появиться в программе в любом месте после определения шаблона, и для данного списка аргументов разрешается появляться в программе только один раз, диагностика не требуется.

template<typename T> void f(T s) { std::cout << s << '\n'; }   template void f<double>(double); // создает экземпляр f<double>(double) template void f<>(char); //создает экземпляр f<char>(char) template void f(int); // создает экземпляр f<int>(int)

template<typename T> void f(T s) { std::cout << s << '\n'; } template void f<double>(double); // создает экземпляр f<double>(double) template void f<>(char); //создает экземпляр f<char>(char) template void f(int); // создает экземпляр f<int>(int)

• Неявное определение экземпляра: Когда код ссылается на функцию в контексте, который требует существования определения функции, и эта конкретная функция не была создана явно, происходит неявное создание экземпляра. Список аргументов шаблона указывать не обязательно, если он может быть выведен из контекста.

#include <iostream>   template<typename T> void f(T s) { std::cout << s << '\n'; }   int main() { f<double>(1); // создает экземпляр и вызывает f<double>(double) f<>('a'); // создает экземпляры и вызывает f<char>(char) f(7); // создает экземпляры и вызывает f<int>(int) void (*ptr)(std::string) = f; // }

#include <iostream> template<typename T> void f(T s) { std::cout << s << '\n'; } int main() { f<double>(1); // создает экземпляр и вызывает f<double>(double) f<>('a'); // создает экземпляры и вызывает f<char>(char) f(7); // создает экземпляры и вызывает f<int>(int) void (*ptr)(std::string) = f; // }

1. Указатель на одномерный массив в динамической памяти

int* p = new int[10]; for (int* q = p; q<p+10; q++) *q = 1;   for (int i=0; i<10; i++) p[i] = 1;   delete [] p;

int* p = new int[10]; for (int* q = p; q<p+10; q++) *q = 1; for (int i=0; i<10; i++) p[i] = 1; delete [] p;

Для простых типов можно написать delete p (подсистема знает, что мы выделили массив), но для классов это ошибка.

Errors related to using of dynamic memory

Error 1. Accessing a section of dynamic memory that we have already returned using delete

int* p = new int; *p = 777; delete p; *p = 666;

int* p = new int; *p = 777; delete p; *p = 666;

• What to do?:

int* p = new int; *p = 777; delete p; p = nullptr; // ! *p = 666;

int* p = new int; *p = 777; delete p; p = nullptr; // ! *p = 666;

• Why it’s not enouph?:

int* p = new int; int * q = p; … delete p; p = nullptr; // ! *q = 666;

int* p = new int; int * q = p; … delete p; p = nullptr; // ! *q = 666;

• Error 2. We returned dynamic memory twice using delete

int* p = new int; *p = 777; delete p; … delete p;

int* p = new int; *p = 777; delete p; … delete p;

• Error 3. Dynamic memory leak

int* p = new int[1000]; *p = 777; … // and forgot to delete!

int* p = new int[1000]; *p = 777; … // and forgot to delete!

• Error 3a. Dynamic memory leak in the loop

for (int i = 0; i<100000; i++) { int* p = new int[1000]; *p = 777; … // and forgot to delete!   }

for (int i = 0; i<100000; i++) { int* p = new int[1000]; *p = 777; … // and forgot to delete! }

• Error 3b. Dynamic memory leak in the function.

void p() { int* p = new int[1000]; *p = 777; … // and forgot to delete! }

void p() { int* p = new int[1000]; *p = 777; … // and forgot to delete! }

• The rule. If dynamic memory is allocated in a function, then it must be returned in the same function. There are exceptions.

Two-dimensional arrays

• A two-dimensional array is considered as a one-dimensional array of one-dimensional arrays

int a[3][4];

int a[3][4];

• Two-dimensional rectangular arrays («matrices») are conveniently modeled using pointer arrays:

int ** mat = new int *[rows]; // future matrix of rows of rows

int ** mat = new int *[rows]; // future matrix of rows of rows

Each element mat[i] of this array is a pointer, it should be initialized in a loop, assigning it the result new int [cols], where cols is the desired number of columns of the matrix.

• The reference to the (i, j)-th element of the matrix looks like this: mat[i][j]. To iterate over the matrix, just as in the case of a regular array, you can use pointers.
• It is necessary to empty (devastate) memory, it should be done in the reverse order: first, the memory for each row is released in the loop: delete [] mat[i]. And then the memory of the array of pointers mat: delete [] mat is released. This procedure should be executed as a function with one argument rows(number of rows).

Another example:

• This is an array of three elements of type int [4]

a[i][j] ~ *(a[i] + j) ~ *(*(a + i) + j)

a[i][j] ~ *(a[i] + j) ~ *(*(a + i) + j)

Printing an array:

void print(int a[][4], int m, int n) { for (int i=0; i<m; i++) { for (int j=0; j<n; j++) cout << a[i][j] << " "; cout << endl; } }

void print(int a[][4], int m, int n) { for (int i=0; i<m; i++) { for (int j=0; j<n; j++) cout << a[i][j] << " "; cout << endl; } }

Two-dimentional arrays and dynamic memory

• In order to pass a two-dimensional array of arbitrary dimension to a function, it should be allocated in dynamic memory:

void print(int** a, int m, int n) { for (int i=0; i<m; i++) { for (int j=0; j<n; j++) cout << a[i][j]; // a[i][j] ~ *(*(a + i) + j) cout << endl; } } int main() { // allocation in memory int** p = new int*[3]; // pointer pointing to pointer (3 rows) for (int i=0; i<3; i++) p[i] = new int[4]; // 4 columns print(p,3,4); … }

void print(int** a, int m, int n) { for (int i=0; i<m; i++) { for (int j=0; j<n; j++) cout << a[i][j]; // a[i][j] ~ *(*(a + i) + j) cout << endl; } } int main() { // allocation in memory int** p = new int*[3]; // pointer pointing to pointer (3 rows) for (int i=0; i<3; i++) p[i] = new int[4]; // 4 columns print(p,3,4); … }

• After using it in the function, the allocated memory must be returned:

int main() { int** p = new int*[3]; for (int i=0; i<3; i++) p[i] = new int[4];   print(p,3,4); // Нарисовать на доске // deallocation of memory: for (int i=0; i<3; i++) delete [] p[i]; delete [] p; p = nullptr; }

int main() { int** p = new int*[3]; for (int i=0; i<3; i++) p[i] = new int[4]; print(p,3,4); // Нарисовать на доске // deallocation of memory: for (int i=0; i<3; i++) delete [] p[i]; delete [] p; p = nullptr; }

Stepwise two-dimensional dynamic arrays

int main() { int** p = new int*[3];   for (int i=0; i<3; i++) p[i] = new int[4];   print(p,3,4); for (int i=0; i<3; i++) delete [] p[i]; delete [] p; p = nullptr; }

int main() { int** p = new int*[3]; for (int i=0; i<3; i++) p[i] = new int[4]; print(p,3,4); for (int i=0; i<3; i++) delete [] p[i]; delete [] p; p = nullptr; }

Лабораторные работы

1. Одномерные массивы в динамической памяти

template <typename T> 
void inputArr(T* arr, int &size);
 
template <typename T>
void printArr(const T* arr, int &size);

Lab 1:
Array[0] 1.1
Array[1] 2.1
Array[2] 3.2
Array[3] 4.1
Array[4] 5.4

1.1 2.1 3.2 4.1 5.4 

✍ Алгоритм:

void MakeArrayWithZero(int* a, int& size);

template<typename T>
void printArray(T const * arr, int size, char delim = ' ') {
  ...
}

Task 1:
Исходный массив:
1 20 30 4 5 
Результирующий массив:
1 0 0 4 5

int* delete_all_entries(int* a, int size, int n, int& new_size)

template<typename T>
void print_array(T const* a, int size, char delim = ' ');

Задание 2:
исходный массив:
1 2 3 2
число, которое следует удалить:
2
новый массив:
1 3

Двумерные массивы

int ** createMatrix(int rows, int cols, int value = 0);

int ** createMatrix(int rows, int cols, int value) {
}

void printMatrix(int ** mat, int rows, int cols);

Lab 2:
matrix 5 by 5:
0 0 0 0 0
0 0 0 0 0
0 0 0 0 0
0 0 0 0 0

✍ Алгоритм:

void matrixMinMax(int ** mat, int rows, int cols, int &min, int &max);

#include <ctime>
// ...
srand(time(0));
//.. в цикле:
array_name[i][j] = 1 + rand() % 10;

Task 3:
matrix 4 by 5:
5 4 0 7 0
0 8 0 1 2
0 5 0 7 0
4 0 0 9 0

max = 9  min = 0

Task 4:
matrix:
8 3 3 6
6 4 9 8
6 1 9 6
4 5 1 5

sum = 26

Теория

1. Основы работы с указателями

• Указатели — это способ указать местоположение переменной. Вместо хранения значения (5 или символ ‘c’), значением указателя является адрес другой переменной.
• Переменные-указатели имеют размер (количество байт в памяти), имя и значение. Они должны быть объявлены и инициализированы.
• «Указатель» (сам по себе) — это не тип. Это конструктор типов — языковая конструкция, которая при применении к другому типу дает нам новый тип. В частности, добавление звездочки ( * ) после любого типа задает название типу, который является указателем на этот тип.

/* объявляет переменную с именем my_char_pointer с указателем типа на char (переменная, указывающая на символ) */ char * my_char_pointer;

/* объявляет переменную с именем my_char_pointer с указателем типа на char (переменная, указывающая на символ) */ char * my_char_pointer;

Объявление указателя
• Объявление указателя сообщает нам имя переменной и тип переменной, на которую будет указывать этот указатель.



Присваивание указателю
• Можно выполнять присваивание указателям, изменяя их значения. Изменение значения указателя означает изменение того, куда он указывает.
• Прежде чем использовать указатель, необходимо инициализировать его (дать ему что-то, на что можно указывать).
• Если мы не инициализируем указатель перед его использованием, то он будет указывать на какое-то случайное место в программе (это может привести к сбою программы).
• Чтобы получить указатель, указывающий на некоторый адрес, нужно назначить имя полю памяти, а затем нам нужно использовать оператор &.

/* код, который объявляет целое число x и указатель на целое число xPtr */ int x = 5; int *xPtr; xPtr = &x; // устанавливает значение переменной xPtr на адрес x

/* код, который объявляет целое число x и указатель на целое число xPtr */ int x = 5; int *xPtr; xPtr = &x; // устанавливает значение переменной xPtr на адрес x

• x инициализируется значением 5 в той же строке, в которой оно объявлено;
• значение xptr инициализируется местоположением x;
• после того, как он инициализирован, xPtr указывает на переменную x.
• Код &x = 5; не будет скомпилирован. Программист может получить доступ к местоположению переменной, но изменить местоположение переменной невозможно.
Разыменовывание указателя



• Как только у нас появятся указатель на адреса переменных, мы хотим использовать их, «следуя за стрелкой» и изменить ячейку, на которую ссылается указатель.
• Символ звездочка * — унарный оператор, который разыменовывает указатель.
• Обратите внимание, что зеленая стрелка указывает на то, что эта строка еще не была извлечена, следовательно, x все еще имеет значение 5 в концептуальном представлении. Однако, как только строка 7 будет выполнена, значение будет равно 6.

6 7	// Пример использования оператора разыменования: *xPtr = 6; // изменяет значение, которое хptr указывает на 6

// Пример использования оператора разыменования: *xPtr = 6; // изменяет значение, которое хptr указывает на 6

• Обратите внимание, что зеленая стрелка указывает на то, что эта строка еще не была выполнена, следовательно, x все еще имеет значение 5 в концептуальном представлении. Однако, как только строка 7 будет выполнена, значение будет равно 6.

Два контекста в которых используется (*), не путайте их:
1. В объявлении переменной, такой как int *p;, звездочка является частью имени типа и сообщает нам, что нам нужен указатель на какой-либо другой тип (в нашем примере int * — это тип p).
2. Когда звездочка является оператором разыменования. Например, код r = *p; присваивает переменной r новое значение, а именно значение внутри ячейки памяти, на которую указывает p. Код *p = r; изменяет значение внутри ячейки памяти, на которую указывает p, на новое значение, а именно на значение переменной r.

• При работе с указателями, вы будете использовать звездочку сначала для объявления переменной, а затем для ее разыменования. Только переменные, имеющие тип указателя, могут быть разыменованы.

int * q = &y; // совпадает с двумя утверждениями: int *q; q = &y;

int * q = &y; // совпадает с двумя утверждениями: int *q; q = &y;

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

обмен значениями

Выполнение: Необходимо передавать указатели a и b через аргументы функции, как показано ниже:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

#include <iostream>
using namespace std;
 
void swap(int *x, int *y) {
	int temp = *x; // temp временно сохраняет значение, на которое указывает x, =3
	*x = *y; // берем значение, на которое указывает y, которое является значением b (=4)
                  //и сохраняем это в значении, на которое указывает x, а именно в переменной a
	*y = temp; // берем значение temp = 3 и сохраняем его в виде целого числа, 
//на которое указывает y, т.е. в переменной b
}
 
int main() {
	int a = 3;
	int b = 4;
 
	swap(&a, &b);
	cout<<"a = "<< a<< ", b = "<<  b << endl;
	system("pause");
	return 0;
}

Работа с памятью

• На 32-разрядной машине, где размер адресов составляет 32 бита, все пространство памяти начинается с адреса 0x000000000 (в шестнадцатеричном формате каждый 0 представляет 4 бита 0) и заканчивается на 0xFFFFFFFF (напомним, что 0x обозначает шестнадцатеричный, и что каждое F представляет четыре двоичных 1). Каждая программа имеет в своем распоряжении все адресное пространство, и существует соглашение о том, как программа использует этот диапазон адресов.

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


Null
• Если используется значение NULL — указатель ни на что не указывает.
• Нулевой указатель имеет особый тип — void *. Указатель void указывает на на любой тип — мы можем присвоить ему значение int *, double* или любой другой тип указателя, который мы хотим.

2. Указатели и массив

• Массив представляет собой константный указатель на свой первый элемент.
• Доступ к элементу массива с помощью арифметики указателей работает нормально и иногда является естественным способом доступа к элементам. Но в случае, когда нам нужен просто n-й элемент массива, было бы громоздко объявлять указатель, добавлять к нему, а затем разыменовывать его.
• Пример:

// * array : имя массива является указателем на его первый элемент, то есть на 3 void printArr(int *array, int n) { int *ptr = array; // *ptr - это указатель, который указывает на то, куда указывает *array for (int i = 0; i < n; i++) { cout << *ptr; // вывод 1-й итерации - 3, вывод 2-й итерации - 1, // вывод 3-й итерации - 7, //чтобы указатель указывал на ячейку памяти следующего элемента в массиве: // пример адреса ptr = 0x00b5f9a0 ptr++; // 1st 0x00b5f9a4, 2nd 0x00b5f9a8, 0x00b5f9ac, // в массиве нет элемента, но ошибки быть не может // это вызвало бы проблему, если бы мы разыменовали указатель } } int main(){ int arr[4] = { 3,1,7,2 }; printArr(arr, 4); }

// * array : имя массива является указателем на его первый элемент, то есть на 3 void printArr(int *array, int n) { int *ptr = array; // *ptr - это указатель, который указывает на то, куда указывает *array for (int i = 0; i < n; i++) { cout << *ptr; // вывод 1-й итерации - 3, вывод 2-й итерации - 1, // вывод 3-й итерации - 7, //чтобы указатель указывал на ячейку памяти следующего элемента в массиве: // пример адреса ptr = 0x00b5f9a0 ptr++; // 1st 0x00b5f9a4, 2nd 0x00b5f9a8, 0x00b5f9ac, // в массиве нет элемента, но ошибки быть не может // это вызвало бы проблему, если бы мы разыменовали указатель } } int main(){ int arr[4] = { 3,1,7,2 }; printArr(arr, 4); }

• Можно достичь этой цели, проиндексировав массив. Когда мы индексируем массив, мы записываем имя массива, за которым следуют квадратные скобки, содержащие номер элемента, на который мы хотим сослаться. Важно отметить, что в C++ индексы массивов начинаются с нуля — первым элементом массива является myArray[0].

// * array : имя массива является указателем на его первый элемент, то есть на 3 void printArr(int *array, int n) { for (int i = 0; i < n; i++) { cout << array[i]; // 1-я итерация выводит 3, 2-я итерация - 1, 3-я итерация - 7, а затем 2 } } int main(){ int arr[4] = { 3,1,7,2 }; printArr(arr, 4); }

// * array : имя массива является указателем на его первый элемент, то есть на 3 void printArr(int *array, int n) { for (int i = 0; i < n; i++) { cout << array[i]; // 1-я итерация выводит 3, 2-я итерация - 1, 3-я итерация - 7, а затем 2 } } int main(){ int arr[4] = { 3,1,7,2 }; printArr(arr, 4); }

Поставим указатель p на начало массива:

int a[] {1,3,5,7,9}; int* p = a; // переместите указатель на второй элемент: p++; p++;

int a[] {1,3,5,7,9}; int* p = a; // переместите указатель на второй элемент: p++; p++;

Доступ по индексу

int a[] {1,3,5,7,9}; int* p = a; cout << *(p + 1) << endl; // = a[1]=3 cout << *(p + 2) << endl; // = a[2]=5

int a[] {1,3,5,7,9}; int* p = a; cout << *(p + 1) << endl; // = a[1]=3 cout << *(p + 2) << endl; // = a[2]=5

Символьная строка и указатели

char s[6] = "Hello"; // в конце автоматически добавляется \0 
char s[] = "Hello"; // тот же самый результат
char* p = s; // H

Для перебора символьной строки:

char* p = s;
while (*p != 0)
  cout << *p++;

или

char* p = s;
while (*p)
  cout << *p++;

Лабораторные работы

1. Основы работы с указателями

int addP(int var1, int var2);

введите первое число (указатель):
>>>2
введите второе число (которое прибавить):
>>>500
результат: указатель + 500 = 502

✍ Алгоритм:

1) произведение указателя и переменной: p1 * var1
2) сумма указателей:  p1 + p2
3) изменение значения var1 = 5, используя при этом указатель p1
4) изменение адреса указателя: p1(address) = p2(address)

int* p1 = &var1; // объявляем и инициализируем указатель p1 
*p1 = 1; // 1 - это новое значение переменной

void task1(int var1, int var2);

Задание 1:
Введите первое значение:
>>5
Введите второе значение:
>>10
произведение указателя и переменной: 25
сумма указателей: 15
результат смены значения var1, var1 = 5
результат ДО смены адреса, p1 = 0098F7E8
результат смены адреса, p1 = 0116FC90

2. Указатель на массив

int sumArray1(int * array, int n);
int sumArray2(int * array, int n);

array:
1 2 3 4 5
результат выполнения первой функции: sum = 15
результат выполнения второй функции: sum = 15

✍ Алгоритм:

void DelEveryEven(int* array, int n);

Лабораторная работа 3, Массивы:
Исходный массив:
1 2 3 4 5 6 7 8 9
Результат:
1 0 3 0 5 0 7 0 9

✍ Алгоритм:

int maxArray1(int * array, int n);
int maxArray2(int * array, int n);

array:
1 2 3 4 5
результат для первой функции: max = 5
результат для второй функции: max = 5

void SetNegToPos(int* array, int n);

Task 2:
исходный массив:
1 -2 3 4 5 -6 7 8 -9
результат:
1 2 3 4 5 6 7 8 9

int findLargestInd(int * array, int n);

if (array[i] > array[largestIndex]) 
{
...
}

Задание 4:
массив:
1 5 3 2 1
индекс максимального элемента = 1

3. Доступ к с-строкам указателем

char str1[] = "Apple";

int stringEqual(const char * str1, const char * str2);

// lab 4:
результат для 'apple' и 'apple' : 1
++++
// lab 4:
результат для 'apple' и 'apples': 0

✍ Алгоритм:

bool findMo(const char * str);

while (*str != '\0')

Задание 5:
результат для строки 'the movie was nice' =: 1

bool findDog(char* p)

задание 6
строка: Hello world
результат:
0
---
задание 6
строка: my dog is nice
результат:
1

char str[] = "Hello world";

void reverseString (char * str);

// lab 4:
Исходная строка:
Hello world
Результат:
dlrow olleH

✍ Алгоритм:

void numbFromStr(char* str);

while (*str1)
  {
	  pLast = str1; // адрес последнего символа
	  *(str1++);
   }

#include <string>

bool isdigit(char c) {
	// проверка символа: например, можно использовать c<='9' и т.п.

Задание 7:
Строка: Happy 2021 year to u!
подстрока с числом: 2021

char s[] ="...";

 int to_lower(char * str);

while (*str != '\0')

bool isCappital(char ch)
{
    return (ch >= 'A' && ch <= 'Z');
}

Задание 8:
Исходная строка: HelLo wOrLD
Результат: hello world

int eval(char * expr);

int res = *expr++ - '0'; // здесь *expr++  это первый символ в строке

char r = *expr; //*expr  - код в таблице ascii
int res = atoi(&r); // конвертирует код в число

char ch1 = *expr++; // может быть как знаком операции (символом), так и числом

// чтобы использовать переменную, как число:
ch1-'0';

Задание 9:
Строка: 9+4-2-0
Результат: 11

Теория

Строки в C++

• Для работы со строкой должна быть включена библиотека string:

#include <string>

#include <string>

• Переменные строкового типа можно понимать как массив символов.
• К определенному символу в строке можно получить доступ как в обычном массиве, то есть по его индексу:

string str="it's possible to understand it"; cout << str[2] << endl; // вывод: ' for (int i = 0; i <= str.size(); i++) { // для перебора символов строки if (str[i] == ' ') //что-то делаем }

string str="it's possible to understand it"; cout << str[2] << endl; // вывод: ' for (int i = 0; i <= str.size(); i++) { // для перебора символов строки if (str[i] == ' ') //что-то делаем }

Строковые функции

Find()

size_t find (const string& str, size_t pos = 0) const;

• Выполняет поиск в строке первого вхождения последовательности, указанного в аргументах.
• Если указано значение pos, поиск включает только символы в позиции pos или после нее, игнорируя любые возможные вхождения, которые включают символы перед позицией pos.
• size_t — это целочисленный тип без знака, размер любого объекта в байтах.
• константа npos — максимальное значение size_t (обычно = 4294967295)
• Это значение используется в качестве значения параметра len (или sublen) в функциях-членах string, означает «до конца строки».
• В качестве возвращаемого значения оно обычно используется для указания отсутствия совпадений.
• Эта константа определена со значением -1, которое, поскольку size_t является целым типом без знака, является максимально возможным представимым значением для этого типа.
Метод определения того, сколько раз подстрока встречается в строке:

string str="it's possible to understand it"; string substr="it"; size_t f = -1; int counter = 0; while (true) // infinite loop { // f = str.find(substr); //значение f будет равно 0 // 'f+1' требуется для перехода на следующую позицию после найденного совпадения f = str.find(substr, f+1); // на 2-й итерации f = 28 // на 3-й итерации f = 4294967295 это означает, что совпадений больше нет // string::npos = 4294967295 if (f == string::npos) break; counter++; } cout << counter;

string str="it's possible to understand it"; string substr="it"; size_t f = -1; int counter = 0; while (true) // infinite loop { // f = str.find(substr); //значение f будет равно 0 // 'f+1' требуется для перехода на следующую позицию после найденного совпадения f = str.find(substr, f+1); // на 2-й итерации f = 28 // на 3-й итерации f = 4294967295 это означает, что совпадений больше нет // string::npos = 4294967295 if (f == string::npos) break; counter++; } cout << counter;

Управляющие (специальные) символы используются для представления определенных специальных символов в строковых литералах и символьных литералах: \‘ — одинарная кавычка

char c = '\''

char c = '\''

Лабораторные работы

Правила оформления работ:

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

Тип String

bool checkIfChar(string s, char c)

lab 1
"Hello world"
введите символ:
>>> o
результат:
1

✍ Алгоритм:

bool findMo(string s)

if (condition_1 && condition_2){
}

Задание 1
результат для 'Hello world':
0
---
Задание 1
результат для 'My mom':
1

void countWords(string s, int& counter)

задание 3
Введите предложение:
>>>  word1 word2 word3 word4
результат:
4

bool LastAndFirst(string s)

задание 4
Для предложения Hello world
результат:
false
---
задание 4
Для предложения lucky ball
результат:
true

Строковые функции

void findCatFunction(string s, string s0)

s.find(s0) // возвращает -1, если в тексте s нет совпадений с s0

задание 5
для текста: cat word1 word3 word4
результат:
0
---
задание 5
для текста: word1 word3 word4
результат:
cat не найдено
---
задание 5
для текста: word1 cat word3 word4
результат:
cat найдено в позиции 6

int countOccurrence(string s, string s0)

Lab 2
строка 1: it's possible to understand it 
строка 2: it
результат: 2

✍ Алгоритм:

string eraseLast(string s, string s0)
{
	// to do:
        // 
        //
	return s;
}

задание 6:
строка 1: it's possible to understand it
строка 2: it
результат: it's possible to understand

string betweenSpaces(string s)
{
	size_t f1, f2;
	f1 = s.find(" "); // индекс первого пробела
	f2 = s.rfind(" "); // индекс последнего пробела
	// ...;
        // ...;
	return  // ...;
}

задание 7:
строка: it's possible to understand it
результат: possible to understand

Дальше — больше… Урок 4. Перечисления и кортежи в C++ →

Дальше — больше… Урок 5. Векторы и массивы в C++ →

Дальше — больше… Урок 3. C++ Ссылочные переменные →

Дальше — больше… Урок 2. C++ многофайловая компоновка, функции →

Дальше — больше… Урок 1. Создание C++ консольного приложения в Visual Studio →