C++ - разница между `cout & lt; & lt; x` и `cout.operator & lt; & lt; (x)` и `operator (std

Введение в класс std::string_view

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

В стандарте C++17 вводится еще один способ использования строк — с помощью класса std::string_view, который находится в заголовочном файле string_view.

В отличие от объектов класса std::string, которые хранят свою собственную копию строки, класс std::string_view обеспечивает представление (англ. «view») для заданной строки, которая может быть определена где-нибудь в другом месте.

Попробуем переписать код предыдущего примера, заменив каждое вхождение на :

#include <iostream>
#include <string_view>

int main()
{
std::string_view text{ «hello» }; // представление для строки «hello», которое хранится в бинарном виде
std::string_view str{ text }; // представление этой же строки — «hello»
std::string_view more{ str }; // представление этой же строки — «hello»

std::cout << text << ‘ ‘ << str << ‘ ‘ << more << ‘\n’;

return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13

#include <iostream>
#include <string_view>

intmain()

{

std::string_viewtext{«hello»};// представление для строки «hello», которое хранится в бинарном виде

std::string_viewstr{text};// представление этой же строки — «hello»

std::string_viewmore{str};// представление этой же строки — «hello»

std::cout<<text<<‘ ‘<<str<<‘ ‘<<more<<‘\n’;

return;

}

В результате мы получим точно такой же вывод на экран, как и в предыдущем примере, но при этом у нас не будут созданы лишние копии строки . Когда мы копируем объект класса std::string_view, то новый объект std::string_view будет «смотреть» на ту же самую строку, на которую «смотрел» исходный объект. Ко всему прочему, класс std::string_view не только быстр, но и обладает многими функциями, которые мы изучили при работе с классом std::string:

#include <iostream>
#include <string_view>

int main()
{
std::string_view str{ «Trains are fast!» };

std::cout << str.length() << ‘\n’; // 16
std::cout << str.substr(0, str.find(‘ ‘)) << ‘\n’; // Trains
std::cout << (str == «Trains are fast!») << ‘\n’; // 1

// Начиная с C++20
std::cout << str.starts_with(«Boats») << ‘\n’; // 0
std::cout << str.ends_with(«fast!») << ‘\n’; // 1

std::cout << str << ‘\n’; // Trains are fast!

return 0;
}

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

#include <iostream>
#include <string_view>

intmain()

{

std::string_viewstr{«Trains are fast!»};

std::cout<<str.length()<<‘\n’;// 16

std::cout<<str.substr(,str.find(‘ ‘))<<‘\n’;// Trains

std::cout<<(str==»Trains are fast!»)<<‘\n’;// 1

// Начиная с C++20

std::cout<<str.starts_with(«Boats»)<<‘\n’;// 0

std::cout<<str.ends_with(«fast!»)<<‘\n’;// 1

std::cout<<str<<‘\n’;// Trains are fast!

return;

}

Т.к. объект класса std::string_view не создает копии строки, то, изменив исходную строку, мы, тем самым, повлияем и на её представление в связанном с ней объектом std::string_view:

#include <iostream>
#include <string_view>

int main()
{
char arr[]{ «Gold» };
std::string_view str{ arr };

std::cout << str << ‘\n’; // Gold

// Изменяем ‘d’ на ‘f’ в arr
arr = ‘f’;

std::cout << str << ‘\n’; // Golf

return 0;
}

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

#include <iostream>
#include <string_view>

intmain()

{

chararr{«Gold»};

std::string_viewstr{arr};

std::cout<<str<<‘\n’;// Gold

// Изменяем ‘d’ на ‘f’ в arr

arr3=’f’;

std::cout<<str<<‘\n’;// Golf

return;

}

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

Совет: Используйте std::string_view вместо строк C-style. Для строк, которые не планируете изменять в дальнейшем, предпочтительнее использовать класс std::string_view вместо std::string.

Литералы в восьмеричной и шестнадцатеричной системах счисления

В повседневной жизни мы используем десятичную систему счисления, которая состоит из десяти цифр: 0, 1, 2, 3, 4, 5, 6, 7, 8 и 9. По умолчанию язык C++ использует десятичную систему счисления для чисел в программах:

int x = 12; // предполагается, что 12 является числом десятичной системы счисления

1	intx=12;// предполагается, что 12 является числом десятичной системы счисления

В двоичной (бинарной) системе счисления всего 2 цифры: 0 и 1. Значения: 0, 1, 10, 11, 100, 101, 110, 111 и т.д.

Есть еще две другие системы счисления: восьмеричная и шестнадцатеричная.

Восьмеричная система счисления состоит из 8 цифр: 0, 1, 2, 3, 4, 5, 6 и 7. Значения: 0, 1, 2, 3, 4, 5, 6, 7, 10, 11, 12 и т.д.

Примечание: В восьмеричной системе счисления нет цифр 8 и 9, так что сразу перескакиваем от 7 к 10.

Десятичная система счисления	1	2	3	4	5	6	7	8	9	10	11
Восьмеричная система счисления	1	2	3	4	5	6	7	10	11	12	13

Для использования литерала из восьмеричной системы счисления, используйте префикс (ноль):

#include <iostream>

int main()
{
int x = 012; // 0 перед значением означает, что это восьмеричный литерал
std::cout << x;
return 0;
}

1
2
3
4
5
6
7
8

#include <iostream>

intmain()

{

intx=012;// 0 перед значением означает, что это восьмеричный литерал

std::cout<<x;

return;

}

Результат выполнения программы:

Почему 10 вместо 12? Потому что выводит числа в десятичной системе счисления, а 12 в восьмеричной системе = 10 в десятичной.

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

Шестнадцатеричная система счисления состоит из 16 символов: 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, А, В, С, D, Е, F.

Десятичная система	1	2	3	4	5	6	7	8	9	10	11	12	13	14	15	16	17
Шестнадцатеричная система	1	2	3	4	5	6	7	8	9	A	B	C	D	E	F	10	11

Для использования литерала из шестнадцатеричной системы счисления, используйте префикс :

#include <iostream>

int main()
{
int x = 0xF; // 0x перед значением означает, что это шестнадцатеричный литерал
std::cout << x;
return 0;
}

1
2
3
4
5
6
7
8

#include <iostream>

intmain()

{

intx=0xF;// 0x перед значением означает, что это шестнадцатеричный литерал

std::cout<<x;

return;

}

Результат выполнения программы:

Поскольку в этой системе 16 символов, то одна шестнадцатеричная цифра занимает 4 бита. Следовательно, две шестнадцатеричные цифры занимают 1 байт.

Рассмотрим 32-битное целое число из двоичной системы счисления: . Из-за длины и повторения цифр его сложно прочесть. В шестнадцатеричной системе счисления это же значение будет выглядеть следующим образом: . Такой удобный/сжатый формат записи является преимуществом шестнадцатеричной системы счисления, поэтому шестнадцатеричные значения часто используются для представления адресов или необработанных значений в памяти.

До C++14 использовать литерал из двоичной системы счисления было невозможно. Тем не менее, шестнадцатеричная система счисления может нам в этом помочь:

#include <iostream>

int main()
{
int bin(0);
bin = 0x01; // присваиваем переменной бинарный литерал 0000 0001
bin = 0x02; // присваиваем переменной бинарный литерал 0000 0010
bin = 0x04; // присваиваем переменной бинарный литерал 0000 0100
bin = 0x08; // присваиваем переменной бинарный литерал 0000 1000
bin = 0x10; // присваиваем переменной бинарный литерал 0001 0000
bin = 0x20; // присваиваем переменной бинарный литерал 0010 0000
bin = 0x40; // присваиваем переменной бинарный литерал 0100 0000
bin = 0x80; // присваиваем переменной бинарный литерал 1000 0000
bin = 0xFF; // присваиваем переменной бинарный литерал 1111 1111
bin = 0xB3; // присваиваем переменной бинарный литерал 1011 0011
bin = 0xF770; // присваиваем переменной бинарный литерал 1111 0111 0111 0000

return 0;
}

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

#include <iostream>

intmain()

{

intbin();

bin=0x01;// присваиваем переменной бинарный литерал 0000 0001

bin=0x02;// присваиваем переменной бинарный литерал 0000 0010

bin=0x04;// присваиваем переменной бинарный литерал 0000 0100

bin=0x08;// присваиваем переменной бинарный литерал 0000 1000

bin=0x10;// присваиваем переменной бинарный литерал 0001 0000

bin=0x20;// присваиваем переменной бинарный литерал 0010 0000

bin=0x40;// присваиваем переменной бинарный литерал 0100 0000

bin=0x80;// присваиваем переменной бинарный литерал 1000 0000

bin=0xFF;// присваиваем переменной бинарный литерал 1111 1111

bin=0xB3;// присваиваем переменной бинарный литерал 1011 0011

bin=0xF770;// присваиваем переменной бинарный литерал 1111 0111 0111 0000

return;

}

Манипуляторы потока

Функцию — манипулятор потока можно включать в операции помещения в поток и извлечения из потока (<<, >>).
В С++ имеется ряд манипуляторов. Рассмотрим основные:

Манипулятор	Описание
endl	Помещение в выходной поток символа конца строки ‘\n’
dec	Установка основания 10-ой системы счисления
oct	Установка основания 8-ой системы счисления
hex	Установка основания 16-ой системы счисления
setbase	Вывод базовой системы счисления
width(ширина)	Устанавливает ширину поля вывода
fill(‘символ’)	Заполняет пустые знакоместа значением символа
precision(точность)	Устанавливает количество значащих цифр в числе (или после запятой) в зависимости от использования fixed
fixed	Показывает, что установленная точность относится к количеству знаков после запятой
showpos	Показывает знак + для положительных чисел
scientific	Выводит число в экспоненциальной форме
get()	Ожидает ввода символа
getline(указатель, количество)	Ожидает ввода строки символов. Максимальное количество символов ограничено полем количество

Пример Программа ввода-вывода значения переменной в C++

1234567891011

#include <iostream>using namespace std;int main(){ int n; cout << «Введите n:»; cin >> n; cout << «Значение n равно: » << n << endl; cin.get(); cin.get(); return 0;}

12345678910

#include <stdio.h>int main(){ int n; printf(«Введите n:»); scanf(«%d», &n); printf(«Значение n равно: %d\n», n); getchar(); getchar(); return 0;}

Пример

1234567891011121314151617181920212223242526

#include <iostream>using namespace std;int main(){ double a = -112.234; double b = 4.3981; int c = 18; cout << endl << «double number:» << endl; cout << «width(10)» << endl; cout.width(10); cout << a << endl << b << endl; cout << «fill(‘0’)» << endl; cout.fill(‘0’); cout.width(10); cout << a << endl << b << endl; cout.precision(5); cout << «precision(5)» << endl << a << endl << b << endl; cout << «fixed» << endl << fixed << a << endl << b << endl; cout << «showpos» << endl << showpos << a << endl << b << endl; cout << «scientific» << endl << scientific << a << endl << b << endl; cout << endl << «int number:» << endl; cout << showbase << hex << c << » » << showbase << oct << c << » «; cout << showbase << dec << c << endl; cin.get(); return 0;}

12345678910111213141516

#include <iostream>using namespace std;int main(){ cout << fixed; for (double t = 0; t <= 3; t += 0.5) { cout.width(3); cout.precision(1); cout << t; cout.width(8); cout.precision(3); cout << cos(t) << endl; } system(«pause»); return 0;}

Язык C++

Ширина поля, символы-заполнители и выравнивание

Обычно числа выводятся без учета пространства вокруг них. Тем не менее, числа можно выравнивать. Чтобы это сделать, нужно сначала определить ширину поля (т.е. количество пространства (пробелов) вокруг значений).

Флаги группы форматирования adjustfield:

internal — знак значения выравнивается по левому краю, а само значение — по правому краю;

left — значение и его знак выравниваются по левому краю;

right — значение и его знак выравниваются по правому краю.

Манипуляторы:

internal — знак значения выравнивается по левому краю, а само значение — по правому краю;

left — значение и его знак выравниваются по левому краю;

right — значение и его знак выравниваются по правому краю;

setfill(char) — задаем символ-заполнитель;

setw(int) — задаем ширину поля.

Методы:

fill() — возвращаем текущий символ-заполнитель;

fill(char) — задаем новый символ-заполнитель;

width() — возвращаем текущую ширину поля;

width(int) — задаем ширину поля.

Чтобы использовать любой из вышеперечисленных объектов, нужно сначала установить ширину поля. Это делается с помощью метода или манипулятора setw()

Обратите внимание, по умолчанию при использовании ширины поля значения выравниваются по правому краю. Например:

#include <iostream>
#include <iomanip> // для setw()

int main()
{
std::cout << -12345 << ‘\n’; // выводим значение без использования ширины поля
std::cout << std::setw(10) << -12345 << ‘\n’; // выводим значение с использованием ширины поля
std::cout << std::setw(10) << std::left << -12345 << ‘\n’; // выравниваем по левому краю
std::cout << std::setw(10) << std::right << -12345 << ‘\n’; // выравниваем по правому краю
std::cout << std::setw(10) << std::internal << -12345 << ‘\n’; // знак значения выравнивается по левому краю, а само значение — по правому
}

1
2
3
4
5
6
7
8
9
10
11

#include <iostream>
#include <iomanip> // для setw()

intmain()

{

std::cout<<-12345<<‘\n’;// выводим значение без использования ширины поля

std::cout<<std::setw(10)<<-12345<<‘\n’;// выводим значение с использованием ширины поля

std::cout<<std::setw(10)<<std::left<<-12345<<‘\n’;// выравниваем по левому краю

std::cout<<std::setw(10)<<std::right<<-12345<<‘\n’;// выравниваем по правому краю

std::cout<<std::setw(10)<<std::internal<<-12345<<‘\n’;// знак значения выравнивается по левому краю, а само значение — по правому

}

Результат:

-12345
-12345
-12345
-12345
— 12345

1
2
3
4
5

-12345

Теперь давайте зададим свой собственный символ-заполнитель:

#include <iostream>
#include <iomanip> // для setw()

int main()
{
std::cout.fill(‘*’);
std::cout << -12345 << ‘\n’; // выводим значение без использования ширины поля
std::cout << std::setw(10) << -12345 << ‘\n’; // выводим значение с использованием ширины поля
std::cout << std::setw(10) << std::left << -12345 << ‘\n’; // выравниваем по левому краю
std::cout << std::setw(10) << std::right << -12345 << ‘\n’; // выравниваем по правому краю
std::cout << std::setw(10) << std::internal << -12345 << ‘\n’; // знак значения выравнивается по левому краю, а само значение — по правому
}

1
2
3
4
5
6
7
8
9
10
11
12

#include <iostream>
#include <iomanip> // для setw()

intmain()

{

std::cout.fill(‘*’);

std::cout<<-12345<<‘\n’;// выводим значение без использования ширины поля

std::cout<<std::setw(10)<<-12345<<‘\n’;// выводим значение с использованием ширины поля

std::cout<<std::setw(10)<<std::left<<-12345<<‘\n’;// выравниваем по левому краю

std::cout<<std::setw(10)<<std::right<<-12345<<‘\n’;// выравниваем по правому краю

std::cout<<std::setw(10)<<std::internal<<-12345<<‘\n’;// знак значения выравнивается по левому краю, а само значение — по правому

}

Результат:

Обратите внимание, всё пустое пространство вокруг чисел заполнено (символом-заполнителем). Класс и библиотека iostream содержат и другие полезные функции, флаги и манипуляторы

Но, как и в случае с классом , рассмотреть их все в рамках данного урока мы не можем. Однако основной функционал и общее представление вы получили

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

ЧТО ВНУТРИ iostream.h

Каждая написанная вами на C++ программа включала заголовочный файл iostream.h. Этот файл содержит определения, позволяющие вашим программам использовать cout для выполнения вывода и cin для выполнения ввода. Более точно, этот файл определяет классы istream и ostream (входной поток и выходной поток), a cin и соut являются переменными (объектами) этих классов. Выберите время, чтобы напечатать файл iostream.h. Он находится в подкаталоге INCLUDE. Определения в этом файле достаточно сложны. Однако если вы пройдете по файлу медленно, то обнаружите, что большинство определений являются просто определениями классов и констант. Внутри файла вы найдете объявления переменных cin и cout.

Решение

Это на самом деле не вариант, что происходит в том, что это строковый литерал. Строковый литерал имеет тип массив из n const char, это просто индекс в массив символов, который в этом случае содержит:

нота добавляется ко всем строковым литералам.

Оператор приводит либо правда или же ложный, поэтому индекс будет:

если ложь, если не равно в результате чего
если правда, если равняется в результате чего

Это довольно загадочно и могло быть заменено простым ,

Для справки стандарт C ++ 14 (Легкость подтвердила, что проект соответствует действующим стандартам) с ближайшим черновиком N3936 в разделе Строковые литералы говорит (акцент мой):

а также:

раздел говорит:

Запись нулевого символа в текстовый поток

Было заявлено, что написание нулевого символа () к текстовому потоку относится неопределенное поведение.

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

и проект стандарта C11 в разделе Streams говорит:

а также печать символов покрыты в Обработка символов <ctype.h>:

со сноской говоря:

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

Мы также можем посмотреть на Обоснование C99 который говорит:

Оператор извлечения

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

#include <iostream>

int main()
{
char buf;
std::cin >> buf;
}

1
2
3
4
5
6
7

#include <iostream>

intmain()

{

charbuf12;

std::cin>>buf;

}

Что произойдет, если пользователь введет 20 символов? Правильно, переполнение. Одним из способов решения этой проблемы является использование манипуляторов. Манипулятор — это объект, который применяется для изменения потока данных с использованием операторов извлечения () или вставки ().

Мы уже работали с одним из манипуляторов — endl, который одновременно выводит символ новой строки и удаляет текущие данные из буфера. Язык C++ предоставляет еще один манипулятор — setw() (из заголовочного файла iomanip), который используется для ограничения количества символов, считываемых из потока. Для использования setw() вам нужно просто передать в качестве параметра максимальное количество символов для извлечения и вставить вызов этого манипулятора следующим образом:

#include <iostream>
#include <iomanip>

int main()
{
char buf;
std::cin >> std::setw(12) >> buf;
}

1
2
3
4
5
6
7
8

#include <iostream>
#include <iomanip>

intmain()

{

charbuf12;

std::cin>>std::setw(12)>>buf;

}

Эта программа теперь прочитает только первые 11 символов из входного потока (+ один символ для нуль-терминатора). Все остальные символы останутся в потоке до следующего извлечения.

Тест

Используя вышеприведенный класс ArrayInt, реализуйте перегрузку оператора присваивания, который будет принимать список инициализации. Следующий код:

int main()
{
ArrayInt array { 7, 6, 5, 4, 3, 2, 1 }; // список инициализации
for (int count = 0; count < array.getLength(); ++count)
std::cout << array << ‘ ‘;

std::cout << ‘\n’;

array = { 1, 4, 9, 12, 15, 17, 19, 21 };

for (int count = 0; count < array.getLength(); ++count)
std::cout << array << ‘ ‘;

return 0;
}

$Что значит & lt; & lt; & quot; \ п & quot; [а == n]; делать?$

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

intmain()

{

ArrayIntarray{7,6,5,4,3,2,1};// список инициализации

for(intcount=;count<array.getLength();++count)

std::cout<<arraycount<<‘ ‘;

std::cout<<‘\n’;

array={1,4,9,12,15,17,19,21};

for(intcount=;count<array.getLength();++count)

std::cout<<arraycount<<‘ ‘;

return;

}

Должен выдавать следующий результат:

Ответ

#include <iostream>
#include <cassert> // для assert()
#include <initializer_list> // для std::initializer_list

class ArrayInt
{
private:
int m_length;
int *m_data;

public:
ArrayInt() :
m_length(0), m_data(nullptr)
{
}

ArrayInt(int length) :
m_length(length)
{
m_data = new int;
}

ArrayInt(const std::initializer_list<int> &list) : // позволяем инициализацию ArrayInt через список инициализации
ArrayInt(list.size()) // используем концепцию делегирования конструкторов для создания начального массива, в который будет выполняться копирование элементов
{
// Инициализируем наш начальный массив значениями из списка
int count = 0;
for (auto &element : list)
{
m_data = element;
++count;
}
}

~ArrayInt()
{
delete[] m_data;
// Нам не нужно здесь присваивать значение null для m_data или выполнять m_length = 0, так как объект будет уничтожен сразу же после выполнения этой функции
}

ArrayInt& operator=(const std::initializer_list<int> &list)
{
// Если новый список имеет другой размер, то перевыделяем его
if (list.size() != static_cast<size_t>(m_length))
{
// Удаляем все существующие элементы
delete[] m_data;

// Перевыделяем массив
m_length = list.size();
m_data = new int;
}

// Теперь инициализируем наш массив значениями из списка
int count = 0;
for (auto &element : list)
{
m_data = element;
++count;
}

return *this;
}

int& operator[](int index)
{
assert(index >= 0 && index < m_length);
return m_data;
}

int getLength() { return m_length; }
};

int main()
{
ArrayInt array { 7, 6, 5, 4, 3, 2, 1 }; // список инициализации
for (int count = 0; count < array.getLength(); ++count)
std::cout << array << ‘ ‘;

std::cout << ‘\n’;

array = { 1, 4, 9, 12, 15, 17, 19, 21 };

for (int count = 0; count < array.getLength(); ++count)
std::cout << array << ‘ ‘;

return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88

#include <iostream>
#include <cassert> // для assert()
#include <initializer_list> // для std::initializer_list

classArrayInt

{

private

intm_length;

int*m_data;

public

ArrayInt()

m_length(),m_data(nullptr)

{

}

ArrayInt(intlength)

m_length(length)

{

m_data=newintlength;

}

ArrayInt(conststd::initializer_list<int>&list)// позволяем инициализацию ArrayInt через список инициализации

ArrayInt(list.size())// используем концепцию делегирования конструкторов для создания начального массива, в который будет выполняться копирование элементов

{

// Инициализируем наш начальный массив значениями из списка

intcount=;

for(auto&element list)

{

m_datacount=element;

++count;

}

~ArrayInt()

{

deletem_data;

// Нам не нужно здесь присваивать значение null для m_data или выполнять m_length = 0, так как объект будет уничтожен сразу же после выполнения этой функции

}

ArrayInt&operator=(conststd::initializer_list<int>&list)

{

// Если новый список имеет другой размер, то перевыделяем его

if(list.size()!=static_cast<size_t>(m_length))

{

// Удаляем все существующие элементы

deletem_data;

// Перевыделяем массив

m_length=list.size();

m_data=newintm_length;

}

// Теперь инициализируем наш массив значениями из списка

intcount=;

for(auto&element list)

{

m_datacount=element;

++count;

}

return*this;

}

int&operator(intindex)

{

assert(index>=&&index<m_length);

returnm_dataindex;

}

intgetLength(){returnm_length;}

};

intmain()

{

ArrayIntarray{7,6,5,4,3,2,1};// список инициализации

for(intcount=;count<array.getLength();++count)

std::cout<<arraycount<<‘ ‘;

std::cout<<‘\n’;

array={1,4,9,12,15,17,19,21};

for(intcount=;count<array.getLength();++count)

std::cout<<arraycount<<‘ ‘;

return;

}