Tuple c что это

Посмотреть статус этого предложения можно на @Github/cpp/papers.

Примечания

• Effective Modern C++ by Scott Meyers.
• C++ Templates: The Complete Guide (2nd Edition) by David Vandevoorde, Nicolai M. Josuttis, Douglas Gregor.

Статьи и ссылки:

• C++ Fold Expressions 101 - Fluent C++
• Mundane std::tuple tricks: Getting started - The Old New Thing
• std::index_sequence and its Improvement in C++20 - Fluent C++
• c++ - Is there a tuple for_each() that returns a tuple of all values returned from the functions invoked? - Stack Overflow

Сегодня в OTUS пройдет demo-урок по основам C++, на котором обсудим:

• Что есть суть «современный C++»?
• Какие есть отличительные черты у этого языка?
• В чем его сильные и слабые стороны?

Приглашаем всех заинтересованных начинающих, регистрация по ссылке.

• c++
• шаблоны c++
• основы програмирования

Подробное знакомство с кортежами в C#

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

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

В этой статье мы вспомним, как начиналась история кортежей, и познакомимся с вариантами их использования в последних версиях языка.

Появление кортежей в C#4

В 2010 году вышла новая версия .NET и C#, в которой и появились первые кортежи.

Задача этого нового принципа (нового для C#, конечно) состояла в том, чтобы упростить работу с небольшим числом значений. До этого для сохранения этих значений приходилось либо создавать собственный класс/структуру, либо использовать набор параметров ref — что в обоих случаях было не идеальным решением.

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

private Tuple GetData()
 return new Tuple(true, 47);
>

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

Затем значения из кортежа можно извлекать:

Tuple tuple = new Tuple(true, 47);

bool boolValue = tuple.Item1; // равно 'true'
int intValue = tuple.Item2; // равно '47'

Ничего сложного, но если вы мыслите как я, то свойства Item1 и Item2 оказываются как бы лишенными смысла. Если брать их отдельно, то не получится понять, что именно их значения представляют.

Так что хоть начальная проблема и была решена, разработчикам еще было над чем потрудиться.

Улучшенные кортежи в C# 7

Переместимся на семь лет вперед в 2017 год, когда вышел C#7. В этой версии кортежам было уделено особое внимание.

Теперь нам уже не нужно было использовать сам класс Tuple , а для выражения намерений в нашем распоряжении появились специальные конструкции.

Определение нового кортежа

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

private (bool, int) GetData()
 return (true, 47);
>

Неплохо, но относительно извлечения данных ничего не изменилось — это по-прежнему происходило при помощи Item1 и Item2 .

Именование элементов в кортеже

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

private (bool isSuccessful, int totalItems) GetData()
 return (true, 47);
>

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

Да, в Visual Studio 2022 (и прежних версиях) эти имена элементов мы видим в качестве свойств и можем использовать так, будто они являются свойствами класса. Вот соответствующий код:

var returnedData = GetData();

bool boolValue = returnedData.isSuccessful;
int intValue = returnedData.totalItems;

Теперь мы отчетливо видим, что означает каждый элемент кортежа. И когда у вас будет кортеж со множеством элементов int , вы поблагодарите меня за то, что не нужно вспоминать о том, какую же запись использовать: Item5 или Item6 .

Элементы также можно именовать при создании кортежа, что особенно полезно, когда вы создаете его встроенным, а не возвращаете из метода. Вот подобный код:

var tupleData = (isSuccessful: true, totalItems: 47);

Использование Var с кортежами

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

Посмотрим, что Visual Studio предлагает в качестве рефакторинга этой переменной:

Здесь у нас два варианта:

• использовать вместо var явный тип;
• деконструировать объявление переменной.

Разберем их по очереди.

Определение кортежа как явного типа, а не var

Если мы хотим указать вместо var явный тип, то используем ту же конструкцию, что и в сигнатуре метода:

(bool isSuccessful, int totalItems) returnedData = GetData();

bool boolValue = returnedData.isSuccessful;
int intValue = returnedData.totalItems;

Становится кристально ясно, что именно находится в кортеже.

Однако можно пойти еще дальше и перенести кортежи на новый уровень.

Деконструкция объявления переменной кортежа

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

(bool isSuccessful, int totalItems) = GetData();

bool boolValue = isSuccessful;
int intValue = totalItems;

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

Игнорирование некоторых элементов кортежа

А как быть, если некоторые возвращаемые кортежем элементы вас не интересуют? Обязательно ли придется сталкиваться с этими лишними переменными, которые вы все равно игнорируете? Нет!

Для любого элемента можно использовать отмену (discard), и соответствующий фрагмент кода весьма прост:

(bool isSuccessful, _) = GetData();

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

Что можно хранить в кортеже?

Хранить в кортеже можно практически все. Если сильно захочется, то можно даже создавать кортежи функций. Вот один из способов:

private (Func function1, Func function2) GetFunctionTuples()
 return (() => true, () => false);
>

Сколько элементов вмещает кортеж?

Если использовать старинный класс Tuple , то он ограничен восемью элементами для одного кортежа. Если же вам нужно больше, то последний элемент можно сделать кортежем. Смысл в том, что так можно умещать необходимое количество данных вложенным образом.

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

Интересно отметить, что метод .ToTuple() , доступный для созданных таким образом кортежей, преобразует современный их вариант в класс Tuple . При этом в случае присутствия в исходном кортеже выходящих за его пределы элементов, он использует описанное выше вложение. Вот код:

Сравнение кортежей

Кортежи — это последовательности значений, то есть их вполне можно сравнивать. Однако здесь нужно учитывать ряд нюансов.

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

var tuple1 = (1, 2, 3);
var tuple2 = (1, 2, 3);

bool isEqual = tuple1.Equals(tuple2); // Дает 'true'

Если вы используете C# 7.3 и выше, то также можете выполнять эту проверку равенства с помощью == :

var tuple1 = (1, 2, 3);
var tuple2 = (1, 2, 3);

bool isEqual = tuple1 == tuple2; // Дает 'true'

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

var tuple1 = (element1: 1, element2: 2, element3: 3);
var tuple2 = (other1: 1, other2: 2, other3: 3);

bool isEqual = tuple1 == tuple2; // Дает 'true'

И это важно помнить, поскольку, даже если именованные элементы совпадают, при сравнении учитывается их порядок:

var tuple1 = (element1: 1, element2: 2, element3: 3);
var tuple2 = (element3: 3, element2: 2, element1: 1);

bool isEqual = tuple1 == tuple2; // Дает 'false'

Нагляднее всего это покажет модульный тест:

[TestMethod]
public void CompareTuple()
 var tuple1 = (element1: 1, element2: 2, element3: 3); 
var tuple2 = (element3: 3, element2: 2, element1: 1);
 
Assert.AreEqual(tuple1, tuple2);
>

При выполнении тест проваливается, и мы получает такой ответ:

Очевидно, что имена элементов здесь отсутствуют — указаны лишь значения в том порядке, в каком они прописаны в кортеже.

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

Выводы

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

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

Кортежи также можно сравнивать, но тут важно помнить, что в сравнении учитывается порядок их элементов, а не имена.

• Создание расширяющих методов на C#
• 5 простейших приемов работы на C#
• Новейшие возможности C# 9

Читайте нас в Telegram, VK и Дзен

Массивы и кортежи

В C++ есть несколько способов объединить группу переменных фиксированного размера в одну переменную.

#Массивы в C

В языке C есть три основных способа определить массив:

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

• Определенный глобально массив a будет лежать в заранее выделенной области памяти на протяжении всего времени исполнения программы. Все элементы изначально заполнены своим значением по умолчанию (для int , нулём).
• Определенный внутри функции массив b будет лежать на стеке — специальной области памяти для временных переменных — и будет удален сразу когда функция (или любой другой блок вроде тела цикла или if -а) завершится. Так как размер стека исполнения ограничен, большие массивы ($>10^6$) выделять так нельзя. Изначально он заполнен чем-то случайным, что лежало на тот момент в памяти — чтобы заполнить нулями, можно написать int x[100] = <> . Чтобы заполнить все элементы заданными значениями, можно написать int y[5] = .
• Определенный через оператор new массив c выделен динамически. Он существует, пока его специально не удалили через оператор del[] . Он также заполнен тем, что на тот момент лежало в памяти. В отличие от предыдущих двух вариантов, он может быть любого размера, даже неизвестного заранее.

Важно. В первых двух вариантах размер массива должен быть известной на момент компиляции константой. Компилятор GCC может скомпилировать выражение вида int a[n] , и действительно выделится массив не-константного размера; IDE поэтому может и не подчеркнуть его, хотя это не является частью стандарта.

Все элементы массива хранятся последовательно в памяти, а сами переменные a , b и c на самом деле являются указателями на первый элемент массива. Скобочки — это просто «синтаксический сахар»:

Для инициализации и копирования в C есть две полезные функции, memset и memcpy соответственно.

Первая берет указатель «куда», указатель «откуда» и количество байт, которые нужно перекопировать:

Вторая берет указатель «куда» и один байт — значение, которое нужно раскопировать по всему массиву.

Важно. memset работает именно с сырыми байтами, а не типами вроде int или float . Поэтому через memset массивы целочисленных типов можно заполнять только «периодичными» значениями, вроде $0$ и $-1$ (отрицательная единица в двоичной записи выглядит как 111..111 ).

Также важно помнить, что последний аргумент в обоих функциях — это число байтов, а не количество элементов. В случае с массивами не-константного размера можно домножить размер типа на размер массива:

Здесь sizeof(int) = 4 . Вместо просто четверки так пишут для самокомментируемости.

#std::array

В C++11 добавили свой класс для массивов константного размера:

; Все операции с ним работают по аналогии с сишными. Основное отличие — он является контейнером STL, то есть у него есть итераторы и с ним работают все алгоритмы из стандартной библиотеки.

С обычными массивами, впрочем, тоже — указатели автоматически приводятся к итераторам:

Массивы из STL, как и обычные массивы константного размера, поддерживают итерирование:

Также можно изменять элементы в массиве во время итерирования следующим синтаксисом:

В STL также есть более ошибкоустойчивая альтернатива memset — std::fill :

Она уже работает с полными типами, хотя и немного медленнее.

#std::pair и std::tuple

Тип pair хранит пару из переменных не обязательно одинаковых типов:

Первый элемент доступен через поле .first , а второй через .second .

Его обобщение, tuple , хранит кортеж из произвольного количества переменных:

Вместо .first , .second , .third и так далее с tuple нужно использовать индексы.

Пары и тюплы удобно возвращать из функций:

Также по массивам из них удобно итерироваться:

#struct

Очень рекомендуется по возможности вместо пар и тюплов объявлять структуры.

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

Единственный минус структур в том, что по для пар и тюплов будут определены функции сравнения и хеширования, и поэтому их можно сразу в таком виде класть в качестве ключа в структуры из STL вроде set или unordered_set , а для структур их нужно писать отдельно.