В том-то и дело, что с литеральной константой компилятор дает лишь предупреждение (об этом выше уже шла речь).
Это как в int попытаться засунуть слишком длинный hex: int v = 0x123456780912345; - ошибки не будет, но будет соотв. предупреждение
В случае с hex все вполне однозначно - компилятор разместит его именно так, как нужно и читать его будет тоже так, как нужно (в зависимости от BE/LE).
С многобайтными литералами получается, что не все так однозначно и это зависит от BE/LE, о чем уже поделился XVR.

С литеральными все понятно и вопроса не было бы. Я про мультибайтную, сорри, попутал. Просто вообще ранее с таким не сталкивался
Блин, Вы меня запутали. Вот "например, '12345678' для 4-байтового int) " просто не скомпилируется, я о том

В том-то и дело, что все компилируется, но с warning
Без warning будет, если число символов строго совпадает с sizeof() соотв. переменной, куда присваиваем.

У меня лично вопрос остался один: какая часть этой слишком длинной литеральной строки будет обрезана в зависимости от BE/LE - правая или левая?

Ну Майкрософт ошибку дает, видимо кто на что горазд. Я С изучал раз 5, как и ++, после чего забывал все без практики. И каждый раз мир открытий чудных. Причем если С еще придраться не особо, то ++ с последними нововведениями скатился в откровенное черти что.

Раз пошла такая пьянка, то договаривайте ))

да нечитаемо все стало, и реально слишком сложно для изучения. К тому же сегодня словил странный глюк в МS на range based loop, как дома проверю - напишу.

Странно ... По мне как раз все наоборот - более свежие стандарты плюсов позволяют наоборот - сделать код проще, меньше текста, лучше читаемость и лучше оптимизация компилятора.
Может M$ идет каким-то своим путем? ..

Старшая. Сначала литеральная константа преобразуется в int (с учетом BE/LE), затем этот int будет усечён (если понадобится) по обычному правилу приведения типов.

Стандарт на этот счет весьма неопределен - implementation dependent

вот что тут https://msdn.microsoft.com/ru-ru/library/zzw4bwhd.aspx Микрософт имел в виду в

и пишут, что v5 = 0 1 2 3 4 . А он нулевой будет в итоге, i это значения ветора по копии, а никак не индекс

По логике i тут должен быть int, для этого тут поставлен auto.
Такая конструкция должна правильно работать уже с C++11. Или я что-то не понимаю?

v5[i] = i; - это фигня полная. Выражение for (auto i : v5) пробежит по всему вектору, присваивая i последовательные значения из этого вектора. Это не индекс. Так как вектор создан нулевым, то это будет так :
v5[0] = 0;
v5[0] = 0;
v5[0] = 0;
v5[0] = 0;
v5[0] = 0;
5 раз
Если сделать

то будет access violation
ибо это v5[10] = 10; 5 раз подряд

Именно из-за вот таких приколов и сложностей в понимании лично я не взлюбил C++. Хотя и достаточно вумных книжек прочитал по нему... Со временем понял, что выражение "Веревка достаточной длины, чтобы выстрелить себе в ногу(с)" имеет смысл. Был у нас один сотрудник, который всегда писал программы с применением, возможно, всех фишек C++. В итоге я ничего не понял из листинга (совсем!) даже относительно несложного проекта, а при попытке объяснить код сам программист пришел в замешательство со словами "ну, так делают другие программисты и оно так проще для понимания и удобнее". Жесть. И вот лично я люблю Си, чистый Си. И, возможно, не прочь выучить C++ нормально - но куда угнаться-то? Постоянно что-то новое. Считаю, что язык должен быть строгим в своем синтаксисе и однозначно трактуемым. Бомбануло у меня, помню, тогда, когда нашел штук пять разных способов инициализации членов класса при объявлении объекта... Брр, даже не стану вспоминать. Можете ругать

По-ходу i - это в данном случае итератор ...

Попытался эти примеры прокомпилить в старом добром keil (компилятор v6).
Примеры собирает, но отлаживать их вообще неудобно: вроде i по окну watch - int, а нифига - это действительно итератор. Пример и правда не работает, как ожидается ((



Честно говоря, не использовал так активно штатные шаблоны (в частности std::vector). До умного for() так и не добрался.
Выяснил, что они могут неявно использовать кучу.
А кучу не использую, в известных целях (речь про обычные МК).

В свое время как-то делал самописный iterator, for_each, умный указатель ... минимально необходимые. Недавно добрался до чудесной штуки - делегаты...
В основном - в академических целях, но потом "проникся" )) Тогда использовал "старые" плюсы.
Но в новых стандартах плюсов они уже есть и готовые (кроме делегатов), но, в очередной раз прихожу к выводу, что они адски "толстые", по крайней мере в применении к обычным МК.

Мне лично из C++11 (для меня нового) пришлись по душе жесткие ограничения при неявном приведении типов - нужно ставить явный static_cast или переписывать код.
Также пригодилась инициализация полей классов прямо в описании класса (например, какие-нить константы), т. е. максимально возможный уход от #define.
const_expr - вообще чудесная штука. Также считаю полезными final и override.... Это пока то, что вспомнил с ходу.

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

i это не итератор, это локальная переменная типа элемента вектора. Сравните

Господа, пора бы остановиться, а? Очень не хочется превращения темы в очередной холивар.
Понятно, что у любых языков, стандартов и компиляторов полно недостатков. Тем более понятно, что умельцы всегда могут наворотить чудес в коде...
Обсуждать всякие причуды, валя всё в кучу, смысла нет, ИМХО.

Нет, давайте не будем. У всех свои предпочтения, но провоцировать свару не надо. Это предупреждение.