Názory k článku
Standard C++14 byl jednomyslně schválen

Pořád lepší než když tvůrce jazyka dobrou featuru úplně odmítne, protože ve své bohorovnosti naznal že není potřeba, například pořád chybějící finally.
Nevhodné featury jdou v projektu zakázat politicky, dělá se to odjakživa, například se občas zakazuje přímé přetypování dat.

Přesně má reakce, když jsem viděl "auto".

Přijde mi to jako strašná pra**rna. U programování by měl člověk přemýšlet.
Pokud nevím ani jakou proměnou použiji, well řekl bych, že jsem se příliš nezamyslel.

Je "auto" "přetypovatelné" za chodu?
Návratová hodnota z funkce (FUUUJ) by asi neměl být problém, ale je možné udělat:
...
auto a;

a=5;
neco_udelej(a); (a je jako int)
a="f*ck to je hnus"
neco_udelej(a); (a jako string)
....
Jak je to s přetěžováním fce s parametrem auto?

Co vím, tak auto je navrženo a zamýšleno stejně, jako var v C#, tj. pouze syntaktický cukr, aby se předešlo zápisům typu

MyClass* inst = new MyClass();

Oproti tomu

auto inst = new MyClass();

je kratší, jednodušší a každý pochopí, jakého typu je proměnná inst. Zvlášť význam to pak dostává u konstrukcí typu

std::vector<int>::const_iterator itr = vect.cbegin();

Ano, jde to použít špatně a nečitelně, ale to jde skoro s čímkoliv.

Jak jsem zmínil, je to pouze syntaktická záležitost a výsledný zkompilovaný kód je stejný, proměnnou nejde deklarovat jako auto bez toho, aby byl jasný její typ. Obdobně pak také nejde měnit její typ za chodu, stejně jako to nejde u žádné jiné proměnné.

V uvedeném příkladu tak byla špatně už samotná deklarace auto a;.

U funkce platí totéž, musí být jasné, jaký typ tam má být a všechny returny musí vracet stejný typ (nebo možná kompatibilní typy v případě polymorfických tříd, nevím přesně, přímo standard jsem nečetl).

Děkuji za osvětlení (všem, nechce se mi psát poděkování ke každému komentáři), teď už mi to přijde jako menší čuňárna.

I když si teď připadám jako debil, že mi to nedošlo, ale radši se zeptat a vypadat jak blb, než jím zůstat :)

U funkce musí všechny returny dedukovat* stejný typ.

* všechny returny kromě prvního mohou být i rekurze

> Přesně má reakce, když jsem viděl "auto".
>
> Přijde mi to jako strašná pra**rna. U programování by měl člověk přemýšlet.
> Pokud nevím ani jakou proměnou použiji, well řekl bych, že jsem se příliš nezamyslel.
>
> Je "auto" "přetypovatelné" za chodu?
> Návratová hodnota z funkce (FUUUJ) by asi neměl být problém, ale je možné udělat:
> ...
> auto a;
>
> a=5;
> neco_udelej(a); (a je jako int)
> a="f*ck to je hnus"
> neco_udelej(a); (a jako string)
> ....
> Jak je to s přetěžováním fce s parametrem auto?

Ty asi v c++ moc neprogramujes co?

Priklad:

template<typename A, typename B>
void f(A a, B b) {
auto x = a + b;
}

Jakeho typu bude promenna x?

- - - -

Jako dalsi dobry priklad pouziti jsem videl treba parsovaci knihovnu, kde slozitejsi parsery se skladaly ze zakladnich. Priklad:

auto p = sequence(repe­at(digit), string("."), repeat(digit));

Kde typ p by byl:

Sequence_parser<Re­peat_parser<Di­git_parser>, String_parser, Repeat_parser<Di­git_parser>>

takze asi trochu otrava psat a menit zaroven s vyrazem na pravo.

- - - -

A ten tvuj priklad by nefungoval. Typ promenne prekladac odvodi pri inicializaci. Pak uz se nemeni.

Nepíšu v C++, proto se ptám :)

auto lze použít pouze v místě, kde chcete pro novou proměnnou použít stejný typ, jako má rvalue, kterou ji inicializujete, tedy je to jen syntactic sugar pro decltype(rvalue). Protože typ rvalue kompilátor (i programátor) stejně potřebuje znát kvůli případnému přetypování, tak to nemá vliv na analýzu ani prasáckost kódu.

(Ještě existuje případ, kdy se auto použije jako syntactic sugar pro postfixovou specifikaci typu, ale to evidentně nemá na analýzu kódu vůbec žádný vliv.)


static int a = 10;
static int& myFunction(){
return a;
}

int main(){
auto var1 = myFunction(); // int var1
decltype(myFun­ction()) var2 = myFunction(); // int& var2
}


Dobře, pokud to má být přesně, tak tedy auto je syntactic sugar pro typename std::remove_re­ference<declty­pe(rvalue)>::ty­pe. Pro decltype(rvalue) je potřeba dost zvláštní konstrukce decltype(auto).

auto var3 = myFunction(); // int var3
decltype(myFun­ction()) var4 = myFunction(); // const int& var4