C ++ 11 ඒකාකාර ආරම්භ කිරීම පැරණි විලාසිතාවේ වාක්‍ය ඛණ්ඩයට ආදේශකයක්ද?

සී ++ 11 හි ඒකාකාර ආරම්භය භාෂාවේ යම් වාචික අපැහැදිලි බවක් විසඳන බව මට වැටහී ඇත, නමුත් බොහෝ බර්න් ස්ට්‍රෝස්ට්‍රප්ගේ ඉදිරිපත් කිරීම්වල (විශේෂයෙන් ගොයිං නේටිව් 2012 කතා වලදී), ඔහුගේ උදාහරණ මූලික වශයෙන් ඔහු වස්තු තැනීමේදී සෑම විටම මෙම වාක්‍ය ඛණ්ඩය භාවිතා කරයි.

සෑම අවස්ථාවකම ඒකාකාරී ආරම්භයක් භාවිතා කිරීම දැන් නිර්දේශ කර තිබේද ? කේතීකරණ විලාසය සහ සාමාන්‍ය භාවිතය දක්වා මෙම නව අංගය සඳහා පොදු ප්‍රවේශය කුමක් විය යුතුද? කිරීමට හේතු මොනවාද නොවේ එය භාවිතා?

මගේ මනසෙහි මම මූලික වශයෙන් වස්තු ඉදිකිරීම මගේ භාවිත අවස්ථාව ලෙස සිතන බව සලකන්න, නමුත් සලකා බැලිය යුතු වෙනත් අවස්ථා තිබේ නම් කරුණාකර මට දන්වන්න.

කේතීකරණ විලාසය අවසානයේ ආත්මීය වන අතර සැලකිය යුතු කාර්යසාධන ප්‍රතිලාභ එයින් ලැබෙනු ඇතැයි සිතිය නොහැකිය. ඒකාකාරී ආරම්භය ලිබරල් භාවිතයෙන් ඔබ ලබා ගන්නා බව මම කියන්නේ මෙන්න:

අතිරික්ත යතුරු නාම අවම කරයි

පහත සඳහන් කරුණු සලකා බලන්න:

vec3 GetValue()
{
  return vec3(x, y, z);
}

මට vec3දෙවරක් ටයිප් කිරීමට අවශ්‍ය ඇයි ? ඒ සඳහා කාරණයක් තිබේද? සම්පාදකයා හොඳ සහ හොඳින් දන්නා අතර ශ්‍රිතය නැවත පැමිණේ. "මෙම අගයන් සමඟ මා ආපසු එන දෙයෙහි ඉදිකිරීම්කරු අමතා එය ආපසු ලබා දෙන්න" යැයි මට කිව නොහැක්කේ ඇයි? ඒකාකාර ආරම්භයක් සමඟ, මට පුළුවන්:

vec3 GetValue()
{
  return {x, y, z};
}

සෑම දෙයක්ම ක්රියා කරයි.

ඊටත් වඩා හොඳ වන්නේ ශ්‍රිත තර්ක සඳහා ය. මෙය සලකා බලන්න:

void DoSomething(const std::string &str);

DoSomething("A string.");

ටයිප් std::stringනාමයක් ටයිප් නොකර එය ක්‍රියා කරයි, මන්දයත් const char*ව්‍යංගයෙන් එය ගොඩනගන්නේ කෙසේදැයි දන්නා බැවිනි . එය අනර්ඝයි. නමුත් එම නූල පැමිණියේ නම්, RapidXML කියන්න. නැත්නම් ලුවා නූලක්. එනම්, මම කියමු, මම ඇත්ත වශයෙන්ම ඉදිරියෙන් ඇති නූල් වල දිග දනිමි. මෙම std::stringඉතා ගත වන බව ඉදිකිරීමටත් const char*මම යන්තම් සමත් නම් වැල දිග ගන්න වෙනවා const char*.

පැහැදිලිවම දිගක් ගතවන අධි බරක් ඇත. නමුත් එය භාවිතා කිරීමට, මට මෙය කිරීමට සිදුවේ : DoSomething(std::string(strValue, strLen)). අමතර ටයිප් නාමය එහි ඇත්තේ ඇයි? වර්ගය කුමක්දැයි සම්පාදකයා දනී. මෙන් auto, අපට අමතර ටයිප් නාම තිබීම වළක්වා ගත හැකිය:

DoSomething({strValue, strLen});

එය ක්‍රියාත්මක වේ. යතුරු ලියන නැත, කරදරයක් නැත, කිසිවක් නැත. සම්පාදකයා සිය කාර්යය ඉටු කරයි, කේතය කෙටි වන අතර සෑම කෙනෙකුම සතුටු වේ.

පළමු අනුවාදය ( DoSomething(std::string(strValue, strLen))) වඩා පැහැදිලිව පෙනෙන බවට තර්ක කළ යුතු බව පිළිගත යුතුය . එනම්, සිදුවන්නේ කුමක්ද සහ කවුරුන් කරන්නේ කුමක්ද යන්න පැහැදිලිය. එය යම් තාක් දුරට සත්‍යයකි; ඒකාකාර ආරම්භක-පදනම් වූ කේතය අවබෝධ කර ගැනීම සඳහා ශ්‍රිත මූලාකෘතිය බැලීම අවශ්‍ය වේ. නියත නොවන යොමු කිරීමකින් ඔබ කිසි විටෙකත් පරාමිතීන් සම්මත නොකළ යුතු යැයි සමහරු පැවසීමට එකම හේතුව මෙයයි: එවිට වටිනාකමක් වෙනස් කරන්නේ නම් ඔබට ඇමතුම් අඩවියේ දැකිය හැකිය.

එහෙත් එය එසේ ම කිව හැකිය auto; ඔබට ලැබෙන්නේ කුමක්ද යන්න දැන ගැනීම auto v = GetSomething();සඳහා අර්ථ දැක්වීම බැලීම අවශ්‍ය වේ GetSomething. නමුත් autoඔබට එයට පිවිසීමෙන් පසු නොසැලකිලිමත් ලෙස අතහැර දැමීම භාවිතා කිරීම නතර වී නැත . පුද්ගලිකව, මම හිතන්නේ ඔබ එය පුරුදු වූ පසු එය හොඳ වනු ඇත. විශේෂයෙන් හොඳ IDE සමඟ.

කිසි විටෙකත් වඩාත්ම කරදරකාරී විග්‍රහය ලබා නොගන්න

මෙන්න කේත කිහිපයක්.

class Bar;

void Func()
{
  int foo(Bar());
}

පොප් ප්‍රශ්නාවලිය: කුමක්ද foo? ඔබ "විචල්යයක්" ලෙස පිළිතුරු දුන්නේ නම්, ඔබ වැරදිය. එය ඇත්ත වශයෙන්ම ශ්‍රිතයක මූලාකෘතිය වන අතර එහි පරාමිතිය ලෙස ශ්‍රිතයක් නැවත ලබා දෙන ශ්‍රිතයක් වන Barඅතර fooශ්‍රිතයේ ප්‍රතිලාභ අගය පූර්ණ වේ.

මෙය C ++ ගේ “වඩාත්ම කරදරකාරී විග්‍රහය” ලෙස හැඳින්වෙන්නේ එය මිනිසෙකුට කිසිසේත්ම තේරුමක් නැති බැවිනි. නමුත් C ++ හි නීති රීති වලට මෙය අවශ්‍ය වේ: එය ක්‍රියාකාරී මූලාකෘතියක් ලෙස අර්ථ දැක්විය හැකි නම් එය එසේ වනු ඇත. ගැටලුව වන්නේ Bar(); එය කාරණා දෙකෙන් එකක් විය හැකිය. එය නම් කරන ලද වර්ගයක් විය හැකිය Bar, එයින් අදහස් කරන්නේ එය තාවකාලික එකක් නිර්මාණය කරන බවයි. නැතහොත් එය පරාමිතීන් නොගෙන ආපසු ලබා දෙන ශ්‍රිතයක් විය හැකිය Bar.

ඒකාකාර ආරම්භය ශ්‍රිත මූලාකෘතියක් ලෙස අර්ථ දැක්විය නොහැක:

class Bar;

void Func()
{
  int foo{Bar{}};
}

Bar{}සෑම විටම තාවකාලික නිර්මාණය කරයි. int foo{...}සෑම විටම විචල්යයක් නිර්මාණය කරයි.

ඔබට භාවිතා කිරීමට අවශ්‍ය අවස්ථා බොහෝමයක් ඇත, Typename()නමුත් C ++ හි විග්‍රහ කිරීමේ නීති නිසා එය කළ නොහැක. සමග Typename{}, අවිනිශ්චිතතාවයක් නොමැත.

එසේ නොකිරීමට හේතු

ඔබ අත්හරින එකම සැබෑ බලය පටු වීමයි. ඒකාකාර ආරම්භයක් සහිත විශාල අගයක් සමඟ ඔබට කුඩා අගයක් ආරම්භ කළ නොහැක.

int val{5.2};

එය සම්පාදනය නොකරනු ඇත. ඔබට එය පැරණි තාලයේ ආරම්භයකින් කළ හැකි නමුත් ඒකාකාරී ආරම්භයක් නොවේ.

ආරම්භක ලැයිස්තු සැබවින්ම ක්‍රියාත්මක කිරීම සඳහා මෙය අර්ධ වශයෙන් සිදු කරන ලදී. එසේ නොවුවහොත්, ආරම්භක ලැයිස්තු වර්ග සම්බන්ධයෙන් නොපැහැදිලි අවස්ථා රාශියක් ඇත.

ඇත්ත වශයෙන්ම, ඇතැම් එවැනි කේතය කියා සමහර අය තර්ක කරනවා , ජාතිය සම්පාදනය වී නැත. මම පෞද්ගලිකව එකඟ වෙමි; පටු වීම ඉතා භයානක වන අතර එය අප්‍රසන්න හැසිරීමට හේතු වේ. සම්පාදක අවධියේදී එම ගැටළු ඉක්මනින් අල්ලා ගැනීම වඩාත් සුදුසුය. අවම වශයෙන්, පටු වීම මඟින් යමෙකු කේතය ගැන එතරම් නොසිතන බව අඟවයි.

ඔබේ අනතුරු ඇඟවීමේ මට්ටම ඉහළ මට්ටමක පවතී නම් සම්පාදකයින් සාමාන්‍යයෙන් මෙවැනි දේ ගැන ඔබට අනතුරු අඟවන බව සැලකිල්ලට ගන්න. ඉතින් ඇත්ත වශයෙන්ම, මේ සියල්ල කරන්නේ අනතුරු ඇඟවීම බලාත්මක දෝෂයක් බවට පත් කිරීමයි. ඔබ කෙසේ හෝ එය කළ යුතු යැයි සමහරු කියනු ඇත;)

එසේ නොකිරීමට තවත් එක් හේතුවක් තිබේ:

std::vector<int> v{100};

මෙය කරන්නේ කුමක්ද? vector<int>පෙරනිමියෙන් සාදන ලද අයිතම සියයක් සමඟ එය නිර්මාණය කළ හැකිය . නැතහොත් එහි vector<int>වටිනාකම 1 අයිතමයක් සමඟ නිර්මාණය කළ හැකිය 100. දෙකම න්‍යායාත්මකව හැකි ය.

ඇත්ත වශයෙන්ම, එය දෙවැන්න කරයි.

මන්ද? ආරම්භක ලැයිස්තු ඒකාකාරී ආරම්භයට සමාන සින්ටැක්ස් භාවිතා කරයි. එබැවින් අපැහැදිලි අවස්ථාවකදී කුමක් කළ යුතුද යන්න පැහැදිලි කිරීමට නීති කිහිපයක් තිබිය යුතුය. රීතිය ඉතා සරල ය: සම්පාදකයාට වරහන්-ආරම්භක ලැයිස්තුවක් සහිත ආරම්භක ලැයිස්තු ඉදිකිරීම්කරුවෙකු භාවිතා කළ හැකි නම් , එසේ වනු ඇත . සිට vector<int>ගනී බව initializer ලැයිස්තුව ඉදිකිරීමටත් ඇත initializer_list<int>, සහ {100} වලංගු විය හැකි initializer_list<int>, එම නිසා එය විය යුතුය .

ප්‍රමාණයේ ඉදිකිරීම්කරු ලබා ගැනීම සඳහා, ඔබ ()ඒ වෙනුවට භාවිතා කළ යුතුය {}.

vectorමෙය පූර්ණ සංඛ්‍යාවක් බවට පරිවර්තනය කළ නොහැකි දෙයක් නම් මෙය සිදු නොවන බව සලකන්න . ආරම්භක_ ලැයිස්තුවක් එම vectorවර්ගයේ ආරම්භක ලැයිස්තු සාදන්නාට නොගැලපේ , එබැවින් සම්පාදකයාට අනෙක් ඉදිකිරීම්කරුවන්ගෙන් තෝරා ගැනීමට නිදහස ඇත.

මම නිකොල් බෝලස්ගේ පිළිතුරේ කොටස සමඟ එකඟ නොවෙමි . කේතය එක් වරක් ලියා කිහිප වතාවක් කියවා ඇති හෙයින්, අප උත්සාහ කළ යුත්තේ කේතය කියවීමට හා තේරුම් ගැනීමට ගතවන කාලය අවම කිරීමට මිස කේත ලිවීමට ගතවන කාලය නොවේ . හුදෙක් ටයිප් කිරීම අවම කිරීමට උත්සාහ කිරීම වැරදි දේ ප්‍රශස්ත කිරීමට උත්සාහ කරයි.

පහත කේතය බලන්න:

vec3 GetValue()
{
  <lots and lots of code here>
  ...
  return {x, y, z};
}

පළමු වරට ඉහත කේතය කියවන කෙනෙකුට ආපසු ප්‍රකාශය ක්ෂණිකව නොතේරෙනු ඇත, මන්ද ඔහු එම රේඛාවට ළඟා වන විට, ආපසු එන වර්ගය ගැන ඔහුට අමතක වනු ඇත. දැන්, ඔහුට නැවත ක්‍රියාකාරී අත්සන වෙත අනුචලනය කිරීමට හෝ නැවත පැමිණීමේ වර්ගය බැලීමට සහ ආපසු ප්‍රකාශය සම්පූර්ණයෙන් තේරුම් ගැනීමට IDE විශේෂාංගයක් භාවිතා කිරීමට සිදුවේ.

පළමු වරට කේතය කියවන කෙනෙකුට සත්‍ය වශයෙන්ම ඉදිකරන්නේ කුමක්ද යන්න තේරුම් ගැනීම මෙහිදී නැවතත් පහසු නැත:

void DoSomething(const std::string &str);
...
const char* strValue = ...;
size_t strLen = ...;

DoSomething({strValue, strLen});

DoSomething වෙනත් සංගීත වර්ගයකට සහය දැක්විය යුතු යැයි යමෙකු තීරණය කළ විට ඉහත කේතය කැඩී යනු ඇත.

void DoSomething(const CoolStringType& str);

CoolStringType හි const char * සහ size_t (std :: string මෙන්) ගන්නා ඉදිකිරීම්කරුවෙකු සිටී නම්, DoSomething ({strValue, strLen}) වෙත ඇමතුම අවිනිශ්චිත දෝෂයක් ඇති කරයි.

සත්‍ය ප්‍රශ්නයට මගේ පිළිතුර:
නැත, ඒකාකාර ආරම්භ කිරීම පැරණි විලාසිතාවේ ඉදිකිරීම් සින්ටැක්ස් වෙනුවට ආදේශකයක් ලෙස නොසිතිය යුතුය.

මගේ තර්කය මෙයයි:
ප්‍රකාශ දෙකකට එකම ආකාරයේ අභිප්‍රායක් නොමැති නම්, ඒවා එක හා සමාන නොවිය යුතුය. වස්තු ආරම්භ කිරීම පිළිබඳ සංකල්ප වර්ග දෙකක් තිබේ:
1) මෙම සියලු අයිතම රැගෙන මා ආරම්භ කරන මෙම වස්තුවට වත් කරන්න.
2) මග පෙන්වීමක් ලෙස මා විසින් සපයන ලද මෙම තර්ක භාවිතා කරමින් මෙම වස්තුව සාදන්න.

සංකල්පය # 1 භාවිතා කිරීමේ උදාහරණ:

struct Collection
{
    int first;
    char second;
    double third;
};

Collection c {1, '2', 3.0};
std::array<int, 3> a {{ 1, 2, 3 }};
std::map<int, char> m { {1, '1'}, {2, '2'}, {3, '3'} };

සංකල්පය # 2 භාවිතා කිරීමේ උදාහරණය:

class Stairs
{
    std::vector<float> stepHeights;

public:
    Stairs(float initHeight, int numSteps, float stepHeight)
    {
        float height = initHeight;

        for (int i = 0; i < numSteps; ++i)
        {
            stepHeights.push_back(height);
            height += stepHeight;
        }
    }
};

Stairs s (2.5, 10, 0.5);

මම හිතන්නේ එය නරක දෙයක් නිසා නව ප්‍රමිතිය මිනිසුන්ට මේ වගේ පඩි පෙළ ආරම්භ කිරීමට ඉඩ දෙයි:

Stairs s {2, 4, 6};

... එය ඉදිකිරීම්කරුගේ අර්ථය අපැහැදිලි කරන බැවිනි. එය ආරම්භ කිරීම සංකල්පය # 1 ලෙස පෙනේ, නමුත් එය එසේ නොවේ. එය පෙනුනත්, පියවර උසෙහි වෙනස් අගයන් තුනක් වස්තුවට වත් නොකරයි. තවද, වඩා වැදගත් දෙය නම්, ඉහත වැනි පඩි පෙළ පුස්තකාල ක්‍රියාත්මක කිරීමක් ප්‍රකාශයට පත් කර ඇති අතර ක්‍රමලේඛකයින් එය භාවිතා කරන්නේ නම්, පසුව පුස්තකාල ක්‍රියාත්මක කරන්නා පසුව ආරම්භක_ ලැයිස්තු ඉදිකිරීම්කරුවෙකු පඩිපෙළට එකතු කරන්නේ නම්, ඒකාකාරී ආරම්භය සමඟ පඩි පෙළ භාවිතා කරන සියලුම කේතය සින්ටැක්ස් කැඩී යයි.

ඒකාකාරී ආරම්භය භාවිතා කරන ආකාරය පිළිබඳ පොදු සම්මුතියකට C ++ ප්‍රජාව එකඟ විය යුතු යැයි මම සිතමි, එනම් සියලු ආරම්භයන් ඒකාකාරව හෝ මා තරයේ යෝජනා කරන පරිදි මෙම ආරම්භක සංකල්ප දෙක වෙන් කොට එමඟින් ක්‍රමලේඛකයාගේ අභිප්‍රාය පා er කයාට පැහැදිලි කරයි. කේතය.

පසුකාලීනව:
පැරණි සින්ටැක්ස් වෙනුවට ආදේශකයක් ලෙස ඒකාකාර ආරම්භය ගැන ඔබ නොසිතීමට තවත් හේතුවක් මෙන්න, සහ සියලු ආරම්භයන් සඳහා ඔබට වරහන් අංකනය භාවිතා කළ නොහැක්කේ ඇයි:

කියන්න, පිටපතක් සෑදීමට ඔබ කැමති වාක්‍ය ඛණ්ඩය:

T var1;
T var2 (var1);

දැන් ඔබ සිතන්නේ ඔබ සියලු ආරම්භක නව බ්‍රේස් සින්ටැක්ස් සමඟ ප්‍රතිස්ථාපනය කළ යුතු වන අතර එවිට ඔබට වඩාත් අනුකූල විය හැකිය (සහ කේතය පෙනෙනු ඇත). නමුත් T වර්ගය සමස්ථයක් නම් වරහන් භාවිතා කරන වාක්‍ය ඛණ්ඩය ක්‍රියා නොකරයි:

T var2 {var1}; // fails if T is std::array for example

පංතියේ ඇතුළත ප්‍රකාශයට පත් merely copy their parametersකර ඇති අදාළ පන්ති විචල්‍යයන්හි ඔබේ ඉදිකිරීම්කරුවන් නම් in exactly the same order, ඒකාකාර ආරම්භය භාවිතා කිරීම අවසානයේදී ඉදිකිරීම්කරු ඇමතීමට වඩා වේගවත් විය හැකිය (නමුත් නියත වශයෙන්ම සමාන විය හැකිය).

නිසැකවම, මෙය ඔබ සැමවිටම ඉදිකිරීම්කරු ප්‍රකාශ කළ යුතුය යන කාරණය වෙනස් නොකරයි.