"Осваиваю" тут нововведение с11++, и захотелось высказаться .

Итак мы имеем теперь крутую хрень :

struct sss
{
  DWORD i1;
  QWORD i2;
  char Name[222];
};

vector <sss> my_arr_of_structs;

for ( auto item: my_arr_of_structs ){
   item.i1 = 0;
   item.i2 = 3;
   memcpy(item.Name,"222",222); // не суть тут пример
}

Красиво. Да. Удобно? Да. ... Вроде бы.....
Вроде бы да — Но вот только это auto item, это "копия" элемента. И что бы добраться до производительности и красоты простого for

for ( size_t i=0; i<my_arr_of_structs.size(); i++){
  my_arr_of_structs[i].i1 =0;
  ...
}

еше очень далеко.

Спрашивается а в чем прикол заставлять делать криво. Что не ужели нельзя было сделать так что бы если тебе надо копию элемента массива то нужно было что-то сделать, а не наоборот?

То есть логика моего "возмущения" такая : Для чего for по массиву? Для того чтобы перебрать элементы и что-то с ними сделать. Но не для того чтобы копировать элемент ( он может быть и 100 кил ) и на него посмотреть.

==
Почему возмущение — ? Да кода написал много, точнее переделал из обычных for на вот эти auto.
Ж)

Здравствуйте, kd112, Вы писали:

K>Спрашивается а в чем прикол заставлять делать криво. Что не ужели нельзя было сделать так что бы если тебе надо копию элемента массива то нужно было что-то сделать, а не наоборот?

Копия необязательна, можно использовать ссылку:

for(auto &item: my_arr_of_structs)
{
    // ...
}

Здравствуйте, kd112, Вы писали:

K>"Осваиваю" тут нововведение с11++, и захотелось высказаться.

Джуны такие джуны.

Здравствуйте, Evgeny.Panasyuk, Вы писали:

EP>Копия необязательна, можно использовать ссылку:

Да я именно про это и говорю.
Нафига разрушать целостность — вот массив это просто элементы. Ну при обычной работе с ним тебе же не требуется как-то объявлять что ты его будешь модифицировать? Ну а тут зачем?

По логике надо было сделать так — хочешь копию пиши типа "auto i: const array".

То есть ИМХА целостность концепции и парадигма поломана.

Здравствуйте, kd112, Вы писали:

K>Да я именно про это и говорю.
K>Нафига разрушать целостность — вот массив это просто элементы. Ну при обычной работе с ним тебе же не требуется как-то объявлять что ты его будешь модифицировать? Ну а тут зачем?
K>По логике надо было сделать так — хочешь копию пиши типа "auto i: const array".
K>То есть ИМХА целостность концепции и парадигма поломана.

Ничего не поломано, всё в "концепции":

auto x = arr[11]; // копия

std::for_each(begin(arr), end(arr), [](auto x) // копия
{
    // ...
});

А вот если бы for(auto x : arr) давал обход по ссылкам, то были бы грабли

Здравствуйте, kd112, Вы писали:

EP>>Копия необязательна, можно использовать ссылку:

K>Да я именно про это и говорю.

тебе даже код показали. в коде после auto надо поставить амперсанд, тогда копий элементов массива не будет

Здравствуйте, uzhas, Вы писали:

K>>Да я именно про это и говорю.

U>тебе даже код показали. в коде после auto надо поставить амперсанд, тогда копий элементов массива не будет

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

То есть все и всегда пишем авто амперсанд. Спрашивается зачем это оверхед?

Здравствуйте, kd112, Вы писали:

K>То есть все и всегда пишем авто амперсанд. Спрашивается зачем это оверхед?

Где тут оверхед? А концепция изначально такая, в функции тоже параметры по значению передаются, если явно ссылку или указатель не укажешь.

Здравствуйте, kd112, Вы писали:

K>То есть все и всегда пишем авто амперсанд. Спрашивается зачем это оверхед?

Консистентность с выводом типов, да и просто инициализацией:

SomeStruct x = arr[11]; // копия
auto x = arr[11]; // копия
/*******/
template<typename T> void foo(T x); // копия
foo(arr[11]);

Я, кстати, иногда (1, 2) for fun делают вот так:

#define let const auto&
// ...
for(let v : vs)
{
    // ...
}

Здравствуйте, kd112, Вы писали:

K>Я именно и говорю, что не надо мне показывать то про что я именно и говорю. Что не понятно?
ну с формулированием мысли у тебя явно проблемы.
изложил бы понятнее и с указанием амперсанда в первом посте. сложилось ощущение, что ты не в курсе о нем

K>Я именно про то что ставить амперсанды это не правильно.
амперсандик поставить довольно просто с одной стороны, а с другой — забыть про него тоже легко — тут есть проблема в виде пенальти по перформансу или в виде неправильной логики.
если логику еще можно покрыть юнит тестам, то перформанс уже тяжело крыть тестами или просить диагностики от компилятора

твое предложение писать const к массиву кажется еще более нелогичным, нежели текущий вариант, т.к. const накладывается (то есть синтаксически сопутствует) на типы, а не на объекты

K>Хочешь работать с копией элементов массива? — напиши это этот массив тебе нужен как конст.
копия и конст — вещи слабо связанные. тут сразу несколько стратегий должно быть:
1) взять по значению (копию) + возможность менять копию
2) взять по значению (копию) без возможности менять копию
3) взять коснт ссылку на элемент массива
4) взять неконст ссылку на элемент массива
собственно, все эти случаи покрываются текущим подходом (с auto + const + амперсанд)
а ты как предложил бы покрыть все эти случаи?


K>То есть все и всегда пишем авто амперсанд. Спрашивается зачем это оверхед?
ну вот опять тебя тяжело понять, оверхеда тут нет (если понимать, что есть оверхед по определению), ибо это всего один символ, тут возможны другие проблемы (я описал некоторые из них выше), описал бы что тебя гнетет и как бы ты решал эту задачу?

Здравствуйте, kd112, Вы писали:

K>Здравствуйте, Evgeny.Panasyuk, Вы писали:

EP>>Копия необязательна, можно использовать ссылку:

K>Да я именно про это и говорю.
K>Нафига разрушать целостность — вот массив это просто элементы. Ну при обычной работе с ним тебе же не требуется как-то объявлять что ты его будешь модифицировать? Ну а тут зачем?

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

Первой идеей было "я бы добавил const"

for ( const auto item: my_arr_of_structs ){
   item.i1 = 0;
   item.i2 = 3;
   memcpy(item.Name,"222",222); // не суть тут пример
}

Но поскольку модификатор можно переставлять, то может получиться, например

for ( auto const item: my_arr_of_structs ){

Что уже теоретически может давать неоднозначность отнесения — константный массив или константны элементы, или и то и другое? Хотя Александреску наверняка бы наколбасил что-то мозговзрывательное вокруг такого подхода

Здравствуйте, Ops, Вы писали:

Ops>Где тут оверхед? А концепция изначально такая, в функции тоже параметры по значению передаются, если явно ссылку или указатель не укажешь.

Так ну зачем делать параллели там где их нет.
Ну функции и есть функции.
А тут просто цикл for который обычно используется как?
Да просто как перебор элементов массива но не через копию.
Вот для того чтобы получить ОБЫЧНЫЙ функционал требуется указать ссылку там где она обычно была не нужна.

Здравствуйте, kd112, Вы писали:

K>А тут просто цикл for который обычно используется как?
Что значит "обычно"?
K>Да просто как перебор элементов массива но не через копию.
Ну, вот, например, надо тебе сумму элементов массива посчитать, зачем для этого возможность модификации?
K>Вот для того чтобы получить ОБЫЧНЫЙ функционал требуется указать ссылку там где она обычно была не нужна.
Не знаю, для кого он "ОБЫЧНЫЙ", для меня лучше возможность модификации указывать явно.

Если ты беспокоишься об эффективности сгенеренного кода, то зря, в большинстве случаев отличия будут лишь в отладочной версии.

Здравствуйте, Ops, Вы писали:

Ops>Если ты беспокоишься об эффективности сгенеренного кода, то зря, в большинстве случаев отличия будут лишь в отладочной версии.

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

> "Осваиваю" тут нововведение с11++, и захотелось высказаться
> ...

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

Я просто использую инструмент неправильно и получаю ерунду.

Инструмент — кривой (а чо он работает не так как в питоне или php). Пойду флеймить на форуме.

Здравствуйте, BulatZiganshin, Вы писали:

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

Здравствуйте, Evgeny.Panasyuk, Вы писали:

EP>Я, кстати, иногда (1, 2) for fun делают вот так:
EP>

EP>#define let const auto&
EP>

lowercase макросы -- зло

Здравствуйте, night beast, Вы писали:

EP>>Я, кстати, иногда (1, 2) for fun делают вот так:
EP>>

EP>>#define let const auto&
EP>>

NB>lowercase макросы -- зло

Предполагается что в конце будет #undef, по типу как в Boost.Asio yield.hpp/unyield.hpp.
lowercase вполне подходит для pseudo-keywords с последующим undef'ом. Особенно учитывая то, что у пользователя есть выбор (как в Boost.Asio) — использовать длинные uppercase имена — BOOST_ASIO_CORO_YIELD, или разрешить вдобавок короткие lowercase — yield.

Здравствуйте, kd112, Вы писали:

K>Хочешь работать с копией элементов массива? — напиши это этот массив тебе нужен как конст.
Ну и будут конст-ссылки, а не копии, раз ты хочешь ссылки по умолчанию.
Как копии-то сделать?

K>То есть все и всегда пишем авто амперсанд. Спрашивается зачем это оверхед?
потому что синтаксис у ссылок такой, с амперсандом.
А у указателей — звездочка, и тоже ведь всега надо писать

ЗЫ А еще есть rvalue-ссылки, они с двумя амперсандами. Что с ними будем делать?

You will always get what you always got
  If you always do  what you always did

Здравствуйте, Evgeny.Panasyuk, Вы писали:

EP>>>Я, кстати, иногда (1, 2) for fun делают вот так:
EP>>>

EP>>>#define let const auto&
EP>>>

NB>>lowercase макросы -- зло

EP>Предполагается что в конце будет #undef, по типу как в Boost.Asio yield.hpp/unyield.hpp.
EP>lowercase вполне подходит для pseudo-keywords с последующим undef'ом. Особенно учитывая то, что у пользователя есть выбор (как в Boost.Asio) — использовать длинные uppercase имена — BOOST_ASIO_CORO_YIELD, или разрешить вдобавок короткие lowercase — yield.

городить такое только чтобы не писать const auto& ?