හැදින්වීම
C ++ පරිශීලක අර්ථ දක්වන ලද වර්ගවල විචල්‍යයන් අගය අර්ථ නිරූපණයන් සමඟ සලකයි . මෙයින් අදහස් කරන්නේ වස්තූන් විවිධ සන්දර්භයන් තුළ ව්‍යංගයෙන් පිටපත් කර ඇති අතර “වස්තුවක් පිටපත් කිරීම” යන්නෙන් සැබවින්ම අදහස් කරන්නේ කුමක්ද යන්න අප තේරුම් ගත යුතුය.
අපි සරල උදාහරණයක් සලකා බලමු:
class person
{
std::string name;
int age;
public:
person(const std::string& name, int age) : name(name), age(age)
{
}
};
int main()
{
person a("Bjarne Stroustrup", 60);
person b(a); // What happens here?
b = a; // And here?
}
(ඔබ name(name), age(age)කොටසින් ව්‍යාකූල වී ඇත්නම් , මෙය සාමාජික ආරම්භක ලැයිස්තුවක් ලෙස හැඳින්වේ .)
විශේෂ සාමාජික කාර්යයන්
personවස්තුවක් පිටපත් කිරීම යන්නෙන් අදහස් කරන්නේ කුමක්ද? මෙම mainකාර්යය පැහැදිලි පිටපත් සිදුවීම් දෙකක් පෙන්වයි. ආරම්භ person b(a);කිරීම පිටපත් සාදන්නා විසින් සිදු කරනු ලැබේ . එහි කාර්යය වන්නේ පවතින වස්තුවක තත්වය මත පදනම්ව නැවුම් වස්තුවක් තැනීමයි. පැවරුම පිටපත් පැවරුම් ක්රියාකරුb = a විසින් සිදු කරනු ලැබේ . එහි කාර්යය සාමාන්‍යයෙන් මඳක් සංකීර්ණ වේ, මන්ද ඉලක්කගත වස්තුව දැනටමත් යම් වලංගු තත්වයක පවතින බැවින් එය සමඟ කටයුතු කළ යුතුය.
පිටපත් සාදන්නා හෝ පැවරුම් ක්රියාකරු (හෝ විනාශ කරන්නා) අප විසින්ම ප්‍රකාශයට පත් කර නොමැති හෙයින්, මේවා අපට ව්‍යංගයෙන් අර්ථ දක්වා ඇත. සම්මතයෙන් උපුටා ගැනීම:
[...] පිටපත් සාදන්නා සහ පිටපත් පැවරුම් ක්රියාකරු, [...] සහ විනාශ කරන්නා විශේෂ සාමාජික කාර්යයන් වේ. [ සටහන : වැඩසටහන පැහැදිලිව ප්‍රකාශ නොකරන විට සමහර පන්ති වර්ග සඳහා මෙම සාමාජික ක්‍රියාකාරකම් ක්‍රියාත්මක කිරීම ව්‍යංගයෙන් ප්‍රකාශ කරනු ඇත.
ඒවා භාවිතා කරන්නේ නම් ක්‍රියාත්මක කිරීම මඟින් ඒවා ව්‍යංගයෙන් අර්ථ දක්වනු ඇත. [...] අවසන් සටහන ] [n3126.pdf 12 වන කොටස]
පෙරනිමියෙන්, වස්තුවක් පිටපත් කිරීම යනු එහි සාමාජිකයන් පිටපත් කිරීම ය:
යූනියන් නොවන පංතිය සඳහා ව්‍යංගයෙන් නිර්වචනය කරන ලද පිටපත් සාදන්නා එහි උප විෂයයන්හි සාමාජික පිටපතක් සිදු කරයි. [n3126.pdf කොටස 12.8 §16]
X නොවන පන්තිය සඳහා ව්‍යංගයෙන් නිර්වචනය කරන ලද පිටපත් පැවරුම් ක්රියාකරු එහි උප විෂයයන්හි සාමාජික පිටපත් කිරීමේ පැවරුම සිදු කරයි. [n3126.pdf කොටස 12.8 §30]
ව්‍යංග අර්ථ දැක්වීම්
මේ සඳහා personපෙනුම සඳහා ව්‍යංගයෙන් අර්ථ දක්වා ඇති විශේෂ සාමාජික කාර්යයන් :
// 1. copy constructor
person(const person& that) : name(that.name), age(that.age)
{
}
// 2. copy assignment operator
person& operator=(const person& that)
{
name = that.name;
age = that.age;
return *this;
}
// 3. destructor
~person()
{
}
Memberwise පිටපත් අපි මේ අවස්ථාවේ දී අවශ්ය දේ හරියටම:
nameහා ageඅපි ස්වයං අන්තර්ගත ස්වාධීන ලබා නිසා, පිටපත් personවස්තුව. ව්‍යංගයෙන් නිර්වචනය කරන ලද විනාශ කරන්නා සෑම විටම හිස් ය. ඉදිකිරීම්කරුගේ සම්පත් අප විසින් අත්පත් කර නොගත් බැවින් මෙයද මෙම අවස්ථාවේ දී හොඳයි. සාමාජිකයාගේ විනාශ කරන්නන් ව්‍යංගයෙන් කැඳවනු personලැබේ.
විනාශ කරන්නාගේ ශරීරය ක්‍රියාත්මක කිරීමෙන් සහ ශරීරය තුළ වෙන් කර ඇති ඕනෑම ස්වයංක්‍රීය වස්තුවක් විනාශ කිරීමෙන් පසුව, X පන්තියේ විනාශ කරන්නෙකු X හි සෘජු [...] සාමාජිකයන් සඳහා විනාශ කරන්නන් අමතයි [n3126.pdf 12.4 §6]
සම්පත් කළමනාකරණය
ඉතින් අපි එම විශේෂ සාමාජික ක්‍රියාකාරකම් පැහැදිලිව ප්‍රකාශ කළ යුත්තේ කවදාද? අපේ පන්තිය සම්පතක් කළමනාකරණය කරන විට, එනම් පන්තියේ වස්තුවක් එම සම්පත සඳහා වගකිව යුතු විට. සාමාන්‍යයෙන් එයින් අදහස් වන්නේ සම්පත ඉදිකිරීම්කරු තුළ අත්පත් කර ගැනීම (හෝ ඉදිකිරීම්කරු වෙත ලබා දීම) සහ විනාශ කරන්නා තුළ මුදා හැරීමයි.
පූර්ව සම්මත C ++ වෙත අපි නැවත යමු. එබඳු දෙයක් නොතිබූ අතර std::string, ක්‍රමලේඛකයින් දර්ශකයන්ට ආදරය කළහ. මෙම personපන්ති මේ හා සමාන ය ඇති විය:
class person
{
char* name;
int age;
public:
// the constructor acquires a resource:
// in this case, dynamic memory obtained via new[]
person(const char* the_name, int the_age)
{
name = new char[strlen(the_name) + 1];
strcpy(name, the_name);
age = the_age;
}
// the destructor must release this resource via delete[]
~person()
{
delete[] name;
}
};
අදටත් මිනිසුන් මෙම ශෛලිය තුල පන්ති ලියන අතර කරදරයට පත්වේ: " මම පුද්ගලයෙකු දෛශිකයකට තල්ලු කළෙමි, දැන් මට පිස්සු මතක දෝෂ ඇතිවේ ! " පෙරනිමියෙන්, වස්තුවක් පිටපත් කිරීම යනු එහි සාමාජිකයන් පිටපත් කිරීම nameපමණක් නොව සාමාජිකයා පිටපත් කිරීම පමණක් බව මතක තබා ගන්න. පිටපත් අවධානය යොමුකළ, නෑ එය පෙන්නුම් චරිතය අරා! මෙය අප්රසන්න බලපෑම් කිහිපයක් ඇත:
- හරහා සිදුවන වෙනස්කම්
aනිරීක්ෂණය කළ හැකිය b.
bවිනාශ වූ පසු , a.nameඅන්තරාදායක දර්ශකයකි.aවිනාශ වුවහොත් , අන්තරාදායක දර්ශකය මකා දැමීමෙන් නිර්වචනය නොකළ හැසිරීමක් ලැබේ.- පැවරුමට
nameපෙර පෙන්වා දුන් දේ සැලකිල්ලට නොගන්නා හෙයින් , ඉක්මනින් හෝ පසුව ඔබට සෑම තැනකම මතක කාන්දු වේ.
පැහැදිලි අර්ථ දැක්වීම්
සාමාජික වශයෙන් පිටපත් කිරීම අපේක්ෂිත බලපෑමක් නොමැති බැවින්, අක්ෂර අරාවේ ගැඹුරු පිටපත් සෑදීම සඳහා අපි පිටපත් සාදන්නා සහ පිටපත් පැවරුම් ක්රියාකරු පැහැදිලිව අර්ථ දැක්විය යුතුය:
// 1. copy constructor
person(const person& that)
{
name = new char[strlen(that.name) + 1];
strcpy(name, that.name);
age = that.age;
}
// 2. copy assignment operator
person& operator=(const person& that)
{
if (this != &that)
{
delete[] name;
// This is a dangerous point in the flow of execution!
// We have temporarily invalidated the class invariants,
// and the next statement might throw an exception,
// leaving the object in an invalid state :(
name = new char[strlen(that.name) + 1];
strcpy(name, that.name);
age = that.age;
}
return *this;
}
ආරම්භ කිරීම සහ පැවරුම අතර වෙනස සැලකිල්ලට ගන්න: nameමතක කාන්දු වීම වැළැක්වීම සඳහා පැවරීමට පෙර අපි පැරණි තත්වය ඉරා දැමිය යුතුය . එසේම, පෝරමයේ ස්වයං පැවරුමෙන් ආරක්ෂා විය යුතුය x = x. එම පරීක්ෂාවකින් තොරව, ප්‍රභවdelete[] name නූල අඩංගු අරාව මකා දමනු ඇත , මන්ද ඔබ ලියන විට දෙකම සහ එකම දර්ශකය අඩංගු වේ.x = xthis->namethat.name
ව්‍යතිරේක ආරක්ෂාව
අවාසනාවකට මෙන්, new char[...]මතක වෙහෙස නිසා ව්‍යතිරේකයක් විසි කළහොත් මෙම විසඳුම අසාර්ථක වනු ඇත . හැකි එක් විසඳුමක් නම් දේශීය විචල්‍යයක් හඳුන්වා දීම සහ ප්‍රකාශ නැවත සකස් කිරීම:
// 2. copy assignment operator
person& operator=(const person& that)
{
char* local_name = new char[strlen(that.name) + 1];
// If the above statement throws,
// the object is still in the same state as before.
// None of the following statements will throw an exception :)
strcpy(local_name, that.name);
delete[] name;
name = local_name;
age = that.age;
return *this;
}
මෙය පැහැදිලි පරීක්ෂාවකින් තොරව ස්වයං පැවරුම ගැන සැලකිලිමත් වේ. මෙම ගැටළුවට ඊටත් වඩා ශක්තිමත් විසඳුමක් වන්නේ පිටපත් හා හුවමාරු මෝඩකමයි , නමුත් මම මෙහි ව්‍යතිරේක ආරක්ෂාව පිළිබඳ විස්තර වෙත නොයමි. පහත සඳහන් කරුණ ඉදිරිපත් කිරීම සඳහා මම ව්‍යතිරේක පමණක් සඳහන් කළෙමි: සම්පත් කළමනාකරණය කරන පන්ති ලිවීම දුෂ්කර ය.
පිටපත් කළ නොහැකි සම්පත්
සමහර සම්පත් ගොනු හැසිරවීම් හෝ මූටෙක්ස් වැනි පිටපත් කළ නොහැක. එවැනි අවස්ථාවක, privateඅර්ථ දැක්වීමක් ලබා නොදී පිටපත් සාදන්නා සහ පිටපත් පැවරුම් ක්රියාකරු ලෙස ප්‍රකාශ කරන්න :
private:
person(const person& that);
person& operator=(const person& that);
විකල්පයක් ලෙස, ඔබට boost::noncopyableඒවා මකාදැමූ බව උරුම කර ගැනීමට හෝ ප්‍රකාශ කිරීමට හැකිය (C ++ 11 සහ ඊට ඉහළින්):
person(const person& that) = delete;
person& operator=(const person& that) = delete;
තුන්දෙනෙකුගේ පාලනය
සමහර විට ඔබ සම්පතක් කළමනාකරණය කරන පන්තියක් ක්‍රියාත්මක කිරීමට අවශ්ය වේ. (තනි පන්තියක කිසි විටෙකත් බහු සම්පත් කළමනාකරණය නොකරන්න, මෙය වේදනාවට පමණක් හේතු වේ.) එවැනි අවස්ථාවකදී, තුනේ රීතිය මතක තබා ගන්න :
ඔබට විනාශ කරන්නා, පිටපත් සාදන්නා හෝ පිටපත් පැවරුම් ක්රියාකරු පැහැදිලිව ප්‍රකාශ කිරීමට අවශ්ය නම්, ඔබ ඔවුන් තිදෙනාම පැහැදිලිව ප්‍රකාශ කළ යුතුය.
(අවාසනාවකට මෙන්, මෙම "රීතිය" සී ++ ප්‍රමිතිය හෝ මා දන්නා කිසිදු සම්පාදකයෙකු විසින් බලාත්මක නොකෙරේ.)
පහේ පාලනය
C ++ 11 සිට, වස්තුවකට අමතර විශේෂ සාමාජික කාර්යයන් 2 ක් ඇත: චලන ඉදිකිරීම්කරු සහ චලනය පැවරීම. මෙම කාර්යයන් ක්‍රියාත්මක කිරීම සඳහා ප්‍රාන්ත පහක රීතිය.
අත්සන් සහිත උදාහරණයක්:
class person
{
std::string name;
int age;
public:
person(const std::string& name, int age); // Ctor
person(const person &) = default; // Copy Ctor
person(person &&) noexcept = default; // Move Ctor
person& operator=(const person &) = default; // Copy Assignment
person& operator=(person &&) noexcept = default; // Move Assignment
~person() noexcept = default; // Dtor
};
බිංදුවේ නියමය
3/5 හි නියමය 0/3/5 හි රීතිය ලෙස ද හැඳින්වේ. රීතියේ ශුන්ය කොටසෙහි දැක්වෙන්නේ ඔබේ පන්තිය නිර්මාණය කිරීමේදී විශේෂ සාමාජික කාර්යයන් කිසිවක් ලිවීමට ඔබට අවසර නැති බවයි.
උපදෙස්
බොහෝ විට, ඔබ විසින්ම සම්පතක් කළමනාකරණය කර ගැනීමට අවශ්ය නොවේ, මන්ද දැනටමත් පවතින පන්තියක් std::stringඔබ වෙනුවෙන් එය කරයි. std::stringසාමාජිකයෙකු භාවිතා කර සරල කේතයක් සංසන්දනය කර දෝෂ සහිත විකල්පයක් සමඟ සංසන්දනය කරන්න . char*එවිට ඔබට ඒත්තු ගැන්විය යුතුය. ඔබ අමු දර්ශක සාමාජිකයන්ගෙන් stay ත්ව සිටින තාක් කල්, තුන්දෙනෙකුගේ රීතිය ඔබේ කේතය ගැන සැලකිලිමත් වීමට අපහසුය.
c++-faqටැගය විකි ඔබ වසා ඡන්දය පෙර .