Как создать массив неопределенной длины в c

Массивы

В структуре данных массива можно хранить несколько переменных одного типа. Чтобы объявить массив, следует указать тип его элементов. Если требуется, чтобы массив мог хранить элементы любого типа, можно указать object в качестве его типа. В унифицированной системе типов C# все типы, стандартные и определяемые пользователем, ссылочные типы и типы значений напрямую или косвенно наследуются из Object.

type[] arrayName; 

Массив имеет следующие свойства:

• Массив может быть одномерным, многомерным или многомерным.
• Число измерений задается при объявлении переменной массива. Длина каждого измерения устанавливается при создании экземпляра массива. Эти значения нельзя изменить во время существования экземпляра.
• Массив массивов является массивом массивов, и каждый массив элементов имеет значение null по умолчанию.
• Массивы индексируются от нуля: массив с n элементами индексируется от 0 до n-1 .
• Элементы массива могут иметь любой тип, в том числе тип массива.
• Типы массивов — это ссылочные типы, производные от абстрактного базового типа Array. Все массивы реализуют IList и IEnumerable. Для итерации по массиву можно использовать оператор foreach. Одномерные массивы также реализуют IList и IEnumerable .

Элементы массива можно инициализировать в известные значения при создании массива. Начиная с C# 12, все типы коллекций можно инициализировать с помощью выражения Collection. Элементы, которые не инициализированы, имеют значение по умолчанию. Значение по умолчанию — это 0-разрядный шаблон. Все ссылочные типы (включая типы, не допускающие значение NULL), имеют значения null . Все типы значений имеют 0-разрядные шаблоны. Это означает, Nullable.HasValue что свойство имеет false значение, и Nullable.Value свойство не определено. В реализации Value .NET свойство создает исключение.

В следующих примерах создаются одномерные массивы, многомерные массивы и массивы массивов:

// Declare a single-dimensional array of 5 integers. int[] array1 = new int[5]; // Declare and set array element values. int[] array2 = [1, 2, 3, 4, 5, 6]; // Declare a two dimensional array. int[,] multiDimensionalArray1 = new int[2, 3]; // Declare and set array element values. int[,] multiDimensionalArray2 = < < 1, 2, 3 >, < 4, 5, 6 >>; // Declare a jagged array. int[][] jaggedArray = new int[6][]; // Set the values of the first array in the jagged array structure. jaggedArray[0] = [1, 2, 3, 4]; 

Одномерные массивы

Одномерный массив — это последовательность таких элементов. Доступ к элементу осуществляется через его индекс. Индекс — это порядковое положение в последовательности. Первый элемент в массиве находится в индексе 0 . Для создания одномерного массива используется оператор new и указывается тип элементов массива и число элементов. В следующем примере объявляются и инициализируется одномерные массивы:

int[] array = new int[5]; string[] weekDays = ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"]; Console.WriteLine(weekDays[0]); Console.WriteLine(weekDays[1]); Console.WriteLine(weekDays[2]); Console.WriteLine(weekDays[3]); Console.WriteLine(weekDays[4]); Console.WriteLine(weekDays[5]); Console.WriteLine(weekDays[6]); /*Output: Sun Mon Tue Wed Thu Fri Sat */ 

Первое объявление объявляет неинициализированный массив из пяти целых чисел от array[0] до array[4] . Элементы массива инициализируются до значения по умолчанию для типа элемента. Для целых чисел это 0 . Второе объявление объявляет массив строк и инициализирует все семь значений этого массива. Оператор foreach выполняет итерацию элементов массива weekday и выводит все значения. Для одномерных массивов оператор обрабатывает элементы в увеличении порядка индексов foreach , начиная с индекса 0 и заканчивая индексом Length — 1 .

Передача одномерных массивов в качестве аргументов

Инициализированный одномерный массив можно передать в метод. В следующем примере массив строк инициализируется и передается в качестве аргумента в метод DisplayArray для строк. Этот метод отображает элементы массива. Затем метод ChangeArray размещает элементы массива в обратном порядке, а метод ChangeArrayElements изменяет первые три элемента массива. После возврата каждого метода метод DisplayArray показывает, что передача массива по значению не препятствует изменению элементов массива.

class ArrayExample < static void DisplayArray(string[] arr) =>Console.WriteLine(string.Join(" ", arr)); // Change the array by reversing its elements. static void ChangeArray(string[] arr) => Array.Reverse(arr); static void ChangeArrayElements(string[] arr) < // Change the value of the first three array elements. arr[0] = "Mon"; arr[1] = "Wed"; arr[2] = "Fri"; >static void Main() < // Declare and initialize an array. string[] weekDays = ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"]; // Display the array elements. DisplayArray(weekDays); Console.WriteLine(); // Reverse the array. ChangeArray(weekDays); // Display the array again to verify that it stays reversed. Console.WriteLine("Array weekDays after the call to ChangeArray:"); DisplayArray(weekDays); Console.WriteLine(); // Assign new values to individual array elements. ChangeArrayElements(weekDays); // Display the array again to verify that it has changed. Console.WriteLine("Array weekDays after the call to ChangeArrayElements:"); DisplayArray(weekDays); >> // The example displays the following output: // Sun Mon Tue Wed Thu Fri Sat // // Array weekDays after the call to ChangeArray: // Sat Fri Thu Wed Tue Mon Sun // // Array weekDays after the call to ChangeArrayElements: // Mon Wed Fri Wed Tue Mon Sun 

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

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

int[,] array2DDeclaration = new int[4, 2]; int[,,] array3DDeclaration = new int[4, 2, 3]; // Two-dimensional array. int[,] array2DInitialization = < < 1, 2 >, < 3, 4 >, < 5, 6 >, < 7, 8 >>; // Three-dimensional array. int[,,] array3D = new int[,,] < < < 1, 2, 3 >, < 4, 5, 6 >>, < < 7, 8, 9 >, < 10, 11, 12 >> >; // Accessing array elements. System.Console.WriteLine(array2DInitialization[0, 0]); System.Console.WriteLine(array2DInitialization[0, 1]); System.Console.WriteLine(array2DInitialization[1, 0]); System.Console.WriteLine(array2DInitialization[1, 1]); System.Console.WriteLine(array2DInitialization[3, 0]); System.Console.WriteLine(array2DInitialization[3, 1]); // Output: // 1 // 2 // 3 // 4 // 7 // 8 System.Console.WriteLine(array3D[1, 0, 1]); System.Console.WriteLine(array3D[1, 1, 2]); // Output: // 8 // 12 // Getting the total count of elements or the length of a given dimension. var allLength = array3D.Length; var total = 1; for (int i = 0; i < array3D.Rank; i++) < total *= array3D.GetLength(i); >System.Console.WriteLine($" equals "); // Output: // 12 equals 12 

Для многомерных массивов элементы пересекаются таким образом, что индексы самого правого измерения увеличиваются сначала, а затем следующее левое измерение и т. д. до самого левого индекса. В следующем примере перечисляется как 2D, так и трехмерный массив:

int[,] numbers2D = < < 9, 99 >, < 3, 33 >, < 5, 55 >>; foreach (int i in numbers2D) < System.Console.Write($""); > // Output: 9 99 3 33 5 55 int[,,] array3D = new int[,,] < < < 1, 2, 3 >, < 4, 5, 6 >>, < < 7, 8, 9 >, < 10, 11, 12 >> >; foreach (int i in array3D) < System.Console.Write($""); > // Output: 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12 

В массиве 2D можно считать левый индекс строкой и правым индексом в качестве столбца .

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

int[,,] array3D = new int[,,] < < < 1, 2, 3 >, < 4, 5, 6 >>, < < 7, 8, 9 >, < 10, 11, 12 >> >; for (int i = 0; i < array3D.GetLength(0); i++) < for (int j = 0; j < array3D.GetLength(1); j++) < for (int k = 0; k < array3D.GetLength(2); k++) < System.Console.Write($""); > System.Console.WriteLine(); > System.Console.WriteLine(); > // Output (including blank lines): // 1 2 3 // 4 5 6 // // 7 8 9 // 10 11 12 // 

Передача многомерных массивов в качестве аргументов

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

static void Print2DArray(int[,] arr) < // Display the array elements. for (int i = 0; i < arr.GetLength(0); i++) < for (int j = 0; j < arr.GetLength(1); j++) < System.Console.WriteLine("Element(,)=", i, j, arr[i, j]); > > > static void ExampleUsage() < // Pass the array as an argument. Print2DArray(new int[,] < < 1, 2 >, < 3, 4 >, < 5, 6 >, < 7, 8 >>); > /* Output: Element(0,0)=1 Element(0,1)=2 Element(1,0)=3 Element(1,1)=4 Element(2,0)=5 Element(2,1)=6 Element(3,0)=7 Element(3,1)=8 */ 

Массивы массивов

Массив массивов — это массив, элементы которого являются массивами и могут быть различных размеров. Многообразный массив иногда называется массивом массивов. Его элементы являются ссылочными типами и инициализированы в null . В следующих примерах показано, как объявлять и инициализировать массивы массивов, а также получать доступ к ним. Первый пример объявляется jaggedArray в одной инструкции. Каждый содержащийся массив создается в последующих инструкциях. Второй пример jaggedArray2 объявлен и инициализирован в одной инструкции. Массивы массивов и многомерные массивы можно смешивать. Последним примером jaggedArray3 является объявление и инициализация одномерного массива, содержащего три двухмерных элемента массива разных размеров.

int[][] jaggedArray = new int[3][]; jaggedArray[0] = [1, 3, 5, 7, 9]; jaggedArray[1] = [0, 2, 4, 6]; jaggedArray[2] = [11, 22]; int[][] jaggedArray2 = [ [1, 3, 5, 7, 9], [0, 2, 4, 6], [11, 22] ]; // Assign 77 to the second element ([1]) of the first array ([0]): jaggedArray2[0][1] = 77; // Assign 88 to the second element ([1]) of the third array ([2]): jaggedArray2[2][1] = 88; int[][,] jaggedArray3 = [ new int[,] < , >, new int[,] < , , >, new int[,] < , , > ]; Console.Write("", jaggedArray3[0][1, 0]); Console.WriteLine(jaggedArray3.Length); 

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

В этом примере создается массив, элементы которого являются массивами. Все элементы массива имеют разный размер.

// Declare the array of two elements. int[][] arr = new int[2][]; // Initialize the elements. arr[0] = [1, 3, 5, 7, 9]; arr[1] = [2, 4, 6, 8]; // Display the array elements. for (int i = 0; i < arr.Length; i++) < System.Console.Write("Element(): ", i); for (int j = 0; j < arr[i].Length; j++) < System.Console.Write("", arr[i][j], j == (arr[i].Length - 1) ? "" : " "); > System.Console.WriteLine(); > /* Output: Element(0): 1 3 5 7 9 Element(1): 2 4 6 8 */ 

Неявно типизированные массивы

Можно создать неявно типизированный массив, в котором тип экземпляра массива выводится из элементов, указанных в инициализаторе массива. Правила для любой неявно типизированной переменной также применяются к неявно типизированным массивам. Дополнительные сведения см. в разделе Неявно типизированные локальные переменные.

В следующих примерах показано, как создать неявно типизированный массив:

int[] a = new[] < 1, 10, 100, 1000 >; // int[] // Accessing array Console.WriteLine("First element: " + a[0]); Console.WriteLine("Second element: " + a[1]); Console.WriteLine("Third element: " + a[2]); Console.WriteLine("Fourth element: " + a[3]); /* Outputs First element: 1 Second element: 10 Third element: 100 Fourth element: 1000 */ var b = new[] < "hello", null, "world" >; // string[] // Accessing elements of an array using 'string.Join' method Console.WriteLine(string.Join(" ", b)); /* Output hello world */ // single-dimension jagged array int[][] c = [ [1,2,3,4], [5,6,7,8] ]; // Looping through the outer array for (int k = 0; k < c.Length; k++) < // Looping through each inner array for (int j = 0; j < c[k].Length; j++) < // Accessing each element and printing it to the console Console.WriteLine($"Element at c[][] is: "); > > /* Outputs Element at c[0][0] is: 1 Element at c[0][1] is: 2 Element at c[0][2] is: 3 Element at c[0][3] is: 4 Element at c[1][0] is: 5 Element at c[1][1] is: 6 Element at c[1][2] is: 7 Element at c[1][3] is: 8 */ // jagged array of strings string[][] d = [ ["Luca", "Mads", "Luke", "Dinesh"], ["Karen", "Suma", "Frances"] ]; // Looping through the outer array int i = 0; foreach (var subArray in d) < // Looping through each inner array int j = 0; foreach (var element in subArray) < // Accessing each element and printing it to the console Console.WriteLine($"Element at d[][] is: "); j++; > i++; > /* Outputs Element at d[0][0] is: Luca Element at d[0][1] is: Mads Element at d[0][2] is: Luke Element at d[0][3] is: Dinesh Element at d[1][0] is: Karen Element at d[1][1] is: Suma Element at d[1][2] is: Frances */ 

В предыдущем примере обратите внимание, что с неявно типизированными массивами квадратные скобки не используются слева от инструкции инициализации. Кроме того, многомерные массивы инициализированы так new [] же, как и одномерные массивы.

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

var contacts = new[] < new < Name = " Eugene Zabokritski", PhoneNumbers = new[] < "206-555-0108", "425-555-0001" >>, new < Name = " Hanying Feng", PhoneNumbers = new[] < "650-555-0199" >> >; 

Совместная работа с нами на GitHub

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

Ввод массива неизвестной длины

Знаю, что есть ф-ция strtok , может, она лучше подойдет? Использовать можно лишь простейшие функции, стандартные типы.

Отслеживать
51.4k 86 86 золотых знаков 267 267 серебряных знаков 505 505 бронзовых знаков
задан 30 дек 2017 в 20:00
Julia Ponomareva Julia Ponomareva
305 5 5 серебряных знаков 16 16 бронзовых знаков
Используйте контейнер, который может расширяться, например, std::vector
30 дек 2017 в 20:09
Мы их не проходили ещё
30 дек 2017 в 20:16
Что значит «в строку вводятся»? Все числа должны находиться в одной строке?
30 дек 2017 в 20:18
пример: 30 40 50
30 дек 2017 в 20:19

Но std::vector — это правильное решение. Если вам нужны какие-то ограничения на решение, стоит упомянуть это в вопросе.

30 дек 2017 в 20:30

1 ответ 1

Сортировка: Сброс на вариант по умолчанию

Как всегда, решение подобных задач может идти по одному из вариантов:

1. Двойной проход: сначала сделать «холостой проход» по входным данным, в котором просто вычислить требуемый размер массива. Затем выделить массив требуемого размера. Затем выполнить второй проход по тем же входным данным, уже помещая их в готовый массив. Этот способ применим только тогда, когда есть возможность многопроходной обработки входных данных и выполнение двух проходов вместо одного не является слишком дорогой операцией.
2. Перевыделение массива: читаемые данные помещаются в массив, размер которого по необходимости наращивается (путем перевыделения памяти) в процессе чтения. Этот способ требует перевыделения памяти (возможно многократной) с копированием все нарастающего и нарастающего объема данных. При большом объеме данных его эффективность (либо по скорости, либо по использованию памяти) может падать существенно.
3. Использование промежуточной легко наращиваемой структуры данных: чтение данных осуществляется в легко наращиваемую структуру данных (например, список), которая по завершению чтения конвертируется в массив. Этот способ является попыткой соединить в себе преимущества первого и второго способа. Платой за это является повышенный расход памяти в процессе чтения (список вместо массива).

У каждого способа есть свои преимущества и недостатки. В вашем — простейшем — случае скорее всего применимы они все. Однако если никаких ограничений на количество входных чисел не накладывается, то, наверное, разумнее всего будет пойти по второму пути.

Схематично, работу по второму пути можно изобразить так

// Изначально у нас есть "массив" нулевого размера std::size_t n = 0; int *a = nullptr; // Читаем значения int value; for (std::size_t i = 0; std::cin >> value; ++i) < if (i >= n) < // Необходимо увеличить размер массива // Вычисляем новый (больший) размер массива в соответствии с // какой-нибудь выбранной стратегией наращивания размера std::size_t new_n = . ; // Например // new_n = i + 1 // или // new_n = n >0 ? n * 2 : 1; // Выделяем новую память int *new_a = new int[new_n]; // Как-то копируем уже существующие данные из старого массива в новый . ; // Уничтожаем старый массив и переходим на использование нового delete[] a; n = new_n; a = new_a; > // Записываем в массив прочитанное значение a[i] = value; > 

Олимпиады по программированию

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

Страницы

• Главная страница
• Задачи с олимпиад
• Разбор заданий из ЕГЭ
• Разбор задач с олимпиад

Поиск по этому блогу

среда, 10 января 2018 г.

Ввод массива неизвестной длины

В некоторых задачах необходимо ввести элементы массива, но при этом сколько элементов не задано точно, кроме этого нужно считывать только данные с одной строки (например, список вершин графа). Как считать до конца строки, т.е. когда нажата клавиша Enter?

int n,a;
cin>>n; //кол-во вершин
vector A[n]; //список смежных вершин
for(int i=0;i <
do <
cin>>a;
A[i].push_back(a);
>while(cin.get()!=10); //если после числа не Enter, но может быть пробел
>

Получается разреженная матрица:

Массивы в C++

Продолжаем серию «C++, копаем вглубь». Цель этой серии — рассказать максимально подробно о разных особенностях языка, возможно довольно специальных. Это четвертая статья из серии, первые три, посвященные перегрузке в C++, находятся здесь, здесь и здесь.

Эта статья посвящена массивам. Массивы можно отнести к наиболее древним слоям C++, они пришли из первых версий C. Тем не менее, массивы вошли в объектно-ориентированную систему типов C++, хотя и с определенными оговорками. Программисту важно знать об этих особенностях, чтобы избежать потенциальных ошибок. В статье также рассмотрено другое наследие C – тривиальные типы и неинициализированные переменные. Часть нововведений C++11, С++14, С++17 затрагивают работу с массивами, все эти новые возможности также подробно описаны. Итак, попробуем рассказать о массивах все.

Оглавление

Оглавление

1. Общие положения

Массив является простейшим агрегатным типом. Он моделирует набор однотипных элементов, расположенных подряд в непрерывном отрезке памяти. Массивы в той или иной форме поддерживаются практически всеми языками программирования и неудивительно, что они появились в первых версиях C и затем стали частью C++.

1.1. Объявление массивов

Если T некоторый тип, N константа или выражение, вычисляемое во время компиляции, то инструкция

T a[N];

объявляет переменную a типа «массив из N элементов типа T » (array of N elements of the type T ). Тип N должен иметь неявное приведение к типу std::size_t , а его значение, называемое размером массива, должно быть больше нуля. Массив располагается в непрерывном отрезке памяти, под каждый элемент массива выделяется sizeof(T) байт, соответственно размер памяти, необходимой для размещения всего массива, равен N*sizeof(T) байт. Эта величина ограничена сверху платформой и компилятором. Тип массива обозначается как T[N] , то есть он включает тип элементов и размер массива. Таким образом, массивы, имеющие одинаковый тип элементов, но разный размер, будут иметь разный тип.

Такие массивы еще называют встроенными массивами (regular arrays), чтобы подчеркнуть отличие от других вариантов массивов, термин «массив» используется в программировании и в том числе в C++ достаточно широко.
Вот примеры правильных объявлений массивов:

const int N = 8; constexpr int Square(int n) < return n * n; >int a1[1]; int a2[N]; int a3['Q']; int a4[Square(2)];

А вот примеры некорректных объявлений массивов:

int n; int b1[0]; // нулевой размер int b2[n]; // размер нельзя определить во время компиляции int b3["Q"]; // размер нельзя привести к size_t

Доступ к элементам массива осуществляется через индексатор, значения индекса от 0 до N-1 . Вот пример:

int a[4]; a[0] = 42; int t = a[3];

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

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

int a[4], b[8];

Для типов массивов можно вводить псевдонимы. Можно использовать традиционный вариант с ключевым словом typedef :

typedef int I4[4];

или более современный (C++11) с ключевым словом using :

using I4 = int[4];

После этого массивы объявляются как простые переменные:

I4 a, b;

Это будет то же самое, что

int a[4], b[4];

1.2. Операторы и стандартные функции для работы с массивами

Для работы с массивами можно использовать оператор sizeof и несколько стандартных функций и макросов.

Оператор sizeof возвращает полный размер массива в байтах, то есть размер элемента умноженный на размер массива.

Макрос _countof() (в MSVS заголовочный файл ) возвращает размер массива, то есть количество элементов. В С++17 появился стандартный шаблон функции std::size() , которая делает то же самое (а еще имеет перегруженную версию, которая определяет размер стандартного контейнера).

int a[4]; std::cout 

16 4

int a[4]< 4, 3, 2, 1 >; for (auto t : a)

std::sort(std::begin(a), std::end(a));

int u, v; int &rr[2] = < u, v >; // ошибка

int * const rr[2] = < &u, &v >;

int u = 42, v = 5; std::reference_wrapper rr[2] = < u, v >; std::cout 

int ff[2](double); // ошибка

int (*ff[2])(double);

auto x[2] = // ошибка

using I4 = int[4]; const I4 ci; // то же, что и const int ci[4];

const int N = 100; int a[N]; for (int *d = a, *end = d + N; d

void Foo(int a[4]); void Foo(int a[]); void Foo(int *a);

// file 1 int A[4]; // file 2 extern int A[];

int a[4]; auto da = a; // тип da выводится как int*

template void Foo(T t);

class B ; class D : public B ; void Foo(B[], int size); // обработка массива элементов типа B

D d[4]; Foo(d, _countof(d));

using I4 = int[4]; I4 a; I4 b = a; // ошибка I4 b; // ошибка I4 b(a); // ошибка I4 b2; b2 = a; // ошибка

I4 Foo(); // ошибка

struct X < int A[4]; >; X x = < >; X x2 = x; // копирование X x3; // копирование X x4; x4 = x; // присваивание X Foo() // возвращаемое значение функции < return < >; >

intptr_t x[4]; auto f = [x]() < return sizeof(x) / sizeof(x[0]); >; std::cout 

intptr_t u[4]; auto g = [x = u]() < return sizeof(x) / sizeof(x[0]); >; std::cout 

int a[4] = < 1, 2, 3, 4 >;

int a[4]< 1, 2, 3, 4 >;

int a[] < 1, 2, 3, 4 >;

int a[4]<>;

const int a[4] = < 3, 2, 1 >;

const char str[] = "meow"; const wchar_t wstr[] = L"meow";

class X < int a[4]< 1, 2, 3, 4 >; int b[2]; // . public: X(int u, int v) : b < u, v ><> // . >;

class X < static int A[]; // . >; int X::A[] = < 1, 2, 3, 4 >;

class X < inline static int A[]< 1, 2, 3, 4 >; // . >;

T t = x1;

class Int < int m_Value; public: Int(int v) : m_Value(v) <>// . >; // . int x, y; // . Int rr[] = < x, y >;

Int rr[] = < Int(x), Int(y) >;

T a[N];

T(*pa)[N] = &a;

int a[4]; int(*pa)[4] = &a; // OK int(*p2)[2] = &a; // ошибка, размеры не совпадают

(*pa)[3] = 42;

using I4 = int[4]; I4 a< 1, 2, 3, 4 >; I4 *pa = &a;

int a[4]; auto pa = &a; // тип pa выводится как int(*)[4]

T a[N];

T(*pa)[N] = &a; T(&ra)[N] = *pa;

int a[4]; int(&ra)[4] = a; // OK int(&r2)[2] = a; // ошибка, размеры не совпадают

ra[3] = 0;

void Foo(T(&a)[N]);

using I4 = int[4]; I4 a< 1, 2, 3, 4 >; I4 &ra = a;

int a[4]; auto &ra = a; // тип ra выводится как int(&)[4]

template void Foo(T& t);

template void Foo(T(&a)[N]);

T a[N][M];

T *dai = a[i]; T(*pai)[M] = &a[i]; T(&rai)[M] = a[i];

T a[N][M]; T(*da)[M] = a;

void Foo(T a[N][M]); void Foo(T a[][M]); void Foo(T(*a)[M]);

using I4 = int[4]; I4 b[2];

int b[2][4];

int b[2][4] = , >;

int b[][4] = , >; // ОК int b[][] = , >; // ошибка

T a[N][M]; T(*pa)[N][M] = &a;

template void Print2dArray(T(&a)[N][M]) < for (int i = 0; i < N; ++i) < for (int j = 0; j < M; ++j) < std::cout std::cout > // . int b[2][4] = , >; Print2dArray(b);

1 2 3 4 5 6 7 8

T mtx[N][M];

T *pa = new T[n];

int *pa = new int[n];

delete[] pa;

int n = 100; std::unique_ptr aptr(new int[n]); for (int i = 0; i

auto aptr = std::make_unique(n);

T(*pa)[M] = new T[n][M];

using I4 = int[4]; I4 *pa = new I4[n];

template class MatrixView // 2D interface to a buffer < T * const m_Buff; int const m_RowCount; int const m_ColCount; public: MatrixView(T* buff, int rowCount, int colCount) : m_Buff(buff) , m_RowCount(rowCount) , m_ColCount(colCount) <>T *operator[](int rowInd) const < return m_Buff + rowInd * m_ColCount; >>; template class DynBuffer // buffer owner < T* const m_Buff; protected: T* Buff() const < return m_Buff; >; DynBuffer(int length) : m_Buff(new T[length]<>) <> ~DynBuffer() < delete[] m_Buff; >DynBuffer(const DynBuffer&) = delete; DynBuffer& operator=(const DynBuffer&) = delete; >; template class MatrixSimple : DynBuffer, public MatrixView < using Buff = DynBuffer; using View = MatrixView; public: MatrixSimple(int rowCount, int colCount) : Buff(rowCount * colCount) , View(Buff::Buff(), rowCount, colCount) <> >;

MatrixSimple mtx(3, 3); mtx[1][2] = 42; // первая строка, второй столбец

// первичный шаблон template struct U < const char* Tag() const < return "primary"; >>; // частичная специализация для указателей template struct U  < const char* Tag() const < return "pointer"; >>; // частичная специализация для массивов template struct U  < const char* Tag() const < return "array"; >>; // частичная специализация для массивов с заданным размером template structs U  < const char* Tag() const < return "array[N]"; >>; U u1; U u2; U u3; U u4; std::cout 

primary pointer array array[N]

std::cout            

1 1 1 0 0 4 8 0 1 1 2 0

template && extent_v == 0, int> s = 0> unique_ptr make_unique(size_t size) < using elem_t = remove_extent_t; // тип элемента массива return unique_ptr(new elem_t[size]<>); >

std::array a;

for (int i = 0; i < a.size(); ++i) < std::cout for (auto it = a.begin(); it != a.end(); ++it) < std::cout for (auto t : a)