ඔබ C ++ හි ව්‍යුහයකට එදිරිව පන්තියක් භාවිතා කළ යුත්තේ කවදාද?

C ++ හි structvs a භාවිතා කිරීම වඩා හොඳ කුමන අවස්ථා classවලදීද?

C ++ හි a classසහ a අතර ඇති වෙනස්කම් structනම්, ව්‍යුහයන්ට පෙරනිමි publicසාමාජිකයන් සහ භෂ්ම සහ පංතිවල පෙරනිමි privateසාමාජිකයන් සහ පදනම් ඇත. පන්ති හා structs දෙකම මිශ්ර කළ හැකි public, protectedසහ private, සාමාජික උරුමය භාවිතා කළ හැකි හා සාමාජික කටයුතු කර ගත හැක.

පංති වැනි ලක්ෂණ නොමැතිව සරල-පැරණි-දත්ත ව්‍යුහයන් ලෙස ව්‍යුහයන් භාවිතා privateකිරීම සහ දත්ත සහ සාමාජික ක්‍රියාකාරකම් සහිත සමස්ත දත්ත ව්‍යුහයන් ලෙස පන්ති භාවිතා කිරීම මම නිර්දේශ කරමි .

අනෙක් සියල්ලන්ම සටහන් කර ඇති පරිදි ඇත්ත වශයෙන්ම ඇත්තේ භාෂා වෙනස්කම් දෙකක් පමණි:

• structපෙරනිමි පොදු ප්‍රවේශයට සහ classපෙරනිමි පුද්ගලික ප්‍රවේශයට.
• උරුම විට, structපෙර සැකසුම publicඋරුමයක් හා classපෙරනිමි privateඋරුමය. (හාස්‍යයට කරුණක් නම්, C ++ හි ඇති බොහෝ දේ මෙන් පෙරනිමිය පසුපසට ය: publicඋරුමය බොහෝ සෙයින් පොදු තේරීම වේ, නමුත් මිනිසුන් කලාතුරකින් ප්‍රකාශ structකරන්නේ “ public” මූල පදය ටයිප් කිරීමෙන් ඉතිරි කර ගැනීම සඳහා ය .

නමුත් ප්‍රායෝගිකව සැබෑ වෙනස වන්නේ class/ structඉදිකිරීම්කරුවෙකු / විනාශ කරන්නෙකු ප්‍රකාශයට පත් කරන / නැති අය අතර ය. "සරල-පැරණි-දත්ත" POD වර්ගයට නිශ්චිත සහතික ඇත, ඔබ පන්තියේ ඉදිකිරීම් භාරගත් පසු තවදුරටත් අදාළ නොවේ. මෙම වෙනස පැහැදිලිව තබා ගැනීම සඳහා, බොහෝ අය හිතාමතාම structPOD වර්ග සඳහා පමණක් භාවිතා කරන අතර, ඔවුන් කිසියම් ක්‍රමයක් එකතු කිරීමට යන්නේ නම්, classes භාවිතා කරන්න . පහත කොටස් දෙක අතර වෙනස වෙනත් ආකාරයකින් අර්ථ විරහිත ය:

class X
{
  public:

  // ...
};

struct X
{
  // ...
};

(අහම්බෙන්, “POD වර්ගය” යන්නෙන් සැබවින්ම අදහස් කරන්නේ කුමක්ද යන්න පිළිබඳ හොඳ පැහැදිලි කිරීම් සහිත නූලක් මෙන්න: C ++ හි POD වර්ග මොනවාද? )

පවතින පිළිතුරු වල වැරදි වැටහීම් රාශියක් ඇත.

දෙකම classසහ structපංතියක් ප්රකාශ කරන්න.

ඔව්, පංතිය ප්‍රකාශ කිරීම සඳහා ඔබ භාවිතා කළ ප්‍රධාන පදය මත පදනම්ව, පන්ති අර්ථ දැක්වීම තුළ ඔබේ ප්‍රවේශ වෙනස් කිරීමේ මූල පද නැවත සකස් කිරීමට ඔබට සිදු විය හැකිය.

එහෙත්, වාක්‍ය ඛණ්ඩයෙන් ඔබ්බට එකක් තෝරා ගැනීමට ඇති එකම හේතුව සම්මුතිය / විලාසය / මනාපයයි.

structසාමාජික ක්‍රියාකාරිත්වයකින් තොරව පන්ති සඳහා මූල පදය සමඟ සම්බන්ධ වීමට සමහර අය කැමතියි , මන්ද එහි ප්‍රති ing ලයක් ලෙස අර්ථ දැක්වීම සී වෙතින් සරල ව්‍යුහයක් "පෙනේ".

ඒ හා සමානව, සමහර අය classසාමාජික ක්‍රියාකාරකම් සහ privateදත්ත සහිත පන්ති සඳහා මූල පදය භාවිතා කිරීමට කැමතියි , මන්ද එය “පන්තිය” යැයි පවසන අතර එම නිසා වස්තු-නැඹුරු වැඩසටහන්කරණය පිළිබඳ ඔවුන්ගේ ප්‍රියතම පොතෙන් උදාහරණ ලෙස පෙනේ.

යථාර්ථය නම් මෙය සම්පූර්ණයෙන්ම ඔබට සහ ඔබේ කණ්ඩායමට පැවරී ඇති අතර එය ඔබේ වැඩසටහනට කිසිදු වෙනසක් නොකරනු ඇත.

පහත දැක්වෙන පංති දෙක ඔවුන්ගේ නම හැර සෑම ආකාරයකින්ම නියත වශයෙන්ම සමාන වේ:

struct Foo
{
   int x;
};

class Bar
{
public:
   int x;
};

නැවත ප්‍රකාශ කිරීමේදී ඔබට මූලික වචන මාරු කළ හැකිය:

class Foo;
struct Bar;

( මෙය අනුකූල නොවන නිසා දෘශ්‍ය ස්ටුඩියෝ ගොඩනැගීම බිඳ දැමුවද, ඔබ මෙය කරන විට සම්පාදකයා අනතුරු ඇඟවීමක් කරයි.)

සහ පහත දැක්වෙන ප්‍රකාශන දෙකම සත්‍ය ලෙස තක්සේරු කරයි:

std::is_class<Foo>::value
std::is_class<Bar>::value

කෙසේ වෙතත්, නැවත අර්ථ දැක්වීමේදී ඔබට මූලික වචන මාරු කළ නොහැකි බව සලකන්න . එයට හේතුව (එක්-අර්ථ දැක්වීමේ රීතියට අනුව) පරිවර්තන ඒකක හරහා අනුපිටපත් පන්ති අර්ථ දැක්වීම් “එකම ටෝකන අනුක්‍රමයකින් සමන්විත විය යුතුය ” . මෙයින් අදහස් කරන්නේ ඔබට හුවමාරු const int member;කර ගැනීමට පවා නොහැකි අතර int const member;, classහෝ අර්ථ නිරූපණය සමඟ කිසිදු සම්බන්ධයක් නැති බවයි struct.

මම පන්තියක් වෙනුවට ව්‍යුහයක් භාවිතා කරන එකම අවස්ථාව වන්නේ ක්‍රියාකාරී ඇමතුමක දී එය භාවිතා කිරීමට පෙර විනෝදකාරකයක් ප්‍රකාශයට පත් කිරීම සහ පැහැදිලිකම සඳහා සින්ටැක්ස් අවම කිරීමට අවශ්‍ය වීමයි. උදා:

struct Compare { bool operator() { ... } };
std::sort(collection.begin(), collection.end(), Compare()); 

සිට C ++ නිතර අසන පැන Lite :

ව්‍යුහයක සාමාජිකයන් සහ මූලික පංති පෙරනිමියෙන් පොදු වන අතර පන්තියේදී ඒවා පෙරනිමියෙන් පුද්ගලික වේ. සටහන: පෙරනිමි මත යැපීමට වඩා ඔබේ මූලික පන්ති පැහැදිලිවම පොදු, පෞද්ගලික හෝ ආරක්‍ෂිත කළ යුතුය.

struct සහ පන්තිය වෙනත් ආකාරයකින් ක්‍රියාකාරී ලෙස සමාන වේ.

හරි, ඒ පිරිසිදු තාක්‍ෂණික කථාව ප්‍රමාණවත්. චිත්තවේගීය වශයෙන්, බොහෝ සංවර්ධකයින් පන්තියක් සහ ව්‍යුහයක් අතර ප්‍රබල වෙනසක් කරයි. ව්‍යුහයක් හුදෙක් සංවෘත හෝ ක්‍රියාකාරීත්වයේ ඉතා සුළු ප්‍රමාණයක් සහිත විවෘත බිටු ගොඩක් මෙන් දැනේ. පංතියක් බුද්ධිමත් සේවාවන්, ශක්තිමත් සංසරණ බාධකයක් සහ මනාව නිර්වචනය කළ අතුරු මුහුණතක් සහිත සමාජයේ ජීවත්වන සහ වගකිවයුතු සාමාජිකයෙකු ලෙස හැඟේ. බොහෝ දෙනෙකුට දැනටමත් ඇති අර්ථය එය බැවින්, ඔබට ක්‍රම කිහිපයක් ඇති සහ පොදු දත්ත ඇති පංතියක් තිබේ නම් ඔබ බොහෝ විට ව්‍යුහාත්මක පදය භාවිතා කළ යුතුය (එවැනි දේ හොඳින් සැලසුම් කරන ලද පද්ධතිවල පවතී!), එසේ නොමැතිනම් ඔබ බොහෝ විට පන්තිය භාවිතා කළ යුතුය මූල පදය.

ව්‍යුහයක් මට ප්‍රයෝජනවත් වූ එක් ස්ථානයක් වන්නේ වෙනත් පද්ධතියකින් ස්ථාවර ආකෘති පණිවිඩ (ඉහත කී අනුක්‍රමික වරාය) ලැබෙන පද්ධතියක් මා සතුව ඇති විටය. ඔබට ඔබේ ක්ෂේත්‍ර නිර්වචනය කරන ව්‍යුහයකට බයිට් ප්‍රවාහය දැමිය හැකි අතර පසුව ක්ෂේත්‍රයන්ට පහසුවෙන් ප්‍රවේශ විය හැකිය.

typedef struct
{
    int messageId;
    int messageCounter;
    int messageData;
} tMessageType;

void processMessage(unsigned char *rawMessage)
{
    tMessageType *messageFields = (tMessageType *)rawMessage;
    printf("MessageId is %d\n", messageFields->messageId);
}

නිසැකවම, ඔබ සී හි කරන දේම මෙයයි, නමුත් පණිවිඩය පන්තියකට විකේතනය කිරීමේ පොදු කාර්යය සාමාන්‍යයෙන් එය වටින්නේ නැති බව මට පෙනී ගියේය.

ඔබ පුස්තකාලයක් ලියන්නේ නම් C ++ හි "struct" භාවිතා කළ හැකි නමුත් API C හෝ C ++ කේතයෙන් ඇමතිය හැකිය. ඔබ සී සහ සී ++ කේත දෙකටම නිරාවරණය වන ව්‍යුහයන් සහ ගෝලීය API කාර්යයන් අඩංගු තනි ශීර්ෂයක් සාදන්න:

// C access Header to a C++ library
#ifdef __cpp
extern "C" {
#endif

// Put your C struct's here
struct foo
{
    ...
};
// NOTE: the typedef is used because C does not automatically generate
// a typedef with the same name as a struct like C++.
typedef struct foo foo;

// Put your C API functions here
void bar(foo *fun);

#ifdef __cpp
}
#endif

එවිට ඔබට C ++ කේතය භාවිතා කර C ++ ගොනුවක ශ්‍රිත තීරුවක් () ලිවිය හැකි අතර එය C වෙතින් ඇමතිය හැකි වන අතර ලෝක දෙකටම ප්‍රකාශිත struct හරහා දත්ත බෙදා ගත හැකිය. සී සහ සී ++ මිශ්‍ර කිරීමේදී ඇත්ත වශයෙන්ම වෙනත් අවවාද තිබේ, නමුත් මෙය සරල උදාහරණයකි.

සෑම කෙනෙකුම පවසන පරිදි, එකම සැබෑ වෙනස වන්නේ පෙරනිමි ප්‍රවේශයයි. සමහර උපකාරක ක්‍රම ක්‍රියාත්මක කළත්, සරල දත්ත පන්තියක් සමඟ කිසිදු ආකාරයක සංවර්‍ධනයක් මට අවශ්‍ය නොවන විට මම විශේෂයෙන් struct භාවිතා කරමි. උදාහරණයක් ලෙස, මට මේ වගේ දෙයක් අවශ්‍ය වූ විට:

struct myvec {
    int x;
    int y;
    int z;

    int length() {return x+y+z;}
};

මගේම ප්‍රශ්නයට පිළිතුරු දීමට (නිර්ලජ්ජිතව), දැනටමත් සඳහන් කර ඇති පරිදි, C ++ හි ඇති එකම වෙනස වන්නේ ප්‍රවේශ වරප්‍රසාදයි.

මම දත්ත ගබඩා කිරීම සඳහා පමණක් ව්‍යුහයක් භාවිතා කිරීමට නැඹුරු වෙමි. දත්ත සමඟ වැඩ කිරීම පහසු කරන්නේ නම් සහායක කාර්යයන් කිහිපයක් ලබා ගැනීමට මම එයට ඉඩ දෙමි. කෙසේ වෙතත් දත්ත වලට ප්‍රවාහ පාලනයක් අවශ්‍ය වූ වහාම (එනම් අභ්‍යන්තර තත්වයක් පවත්වා ගෙන යන හෝ ආරක්ෂා කරන ගැටර්ස් / සෙටර්ස්) හෝ ඕනෑම ප්‍රධාන ක්‍රියාකාරිත්වයක් (මූලික වශයෙන් වඩා වස්තු වැනි) ලබා ගැනීමට පටන් ගත් විට, එය වඩා හොඳ සන්නිවේදනය කිරීමේ අභිප්‍රාය සඳහා පන්තියකට 'උත්ශ්‍රේණිගත' වනු ඇත.

භාෂා මායිම් සහ සම්බන්ධක ආකෘති හරහා අතේ ගෙන යා හැකි බැවින්, C ++ ක්‍රියාත්මක කිරීම සමඟ ඔබ C- අනුකූල අතුරු මුහුණතක් සපයන විට ව්‍යුහයන් ( PODs ) වඩාත් පහසු වේ.

එය ඔබට ප්‍රශ්නයක් නොවේ නම්, "පංතිය" වෙනුවට "ව්‍යුහය" භාවිතා කිරීම හොඳ අභිප්‍රාය සන්නිවේදකයෙකු යැයි මම සිතමි (ඉහත සඳහන් කළ පරිදි @ සීරෝ සිග්නල්). ව්‍යුහයන්ට වඩා අනාවැකි කිව හැකි පිටපත් කිරීමේ අර්ථකථන ඇත, එබැවින් ඔබ බාහිර මාධ්‍ය වෙත ලිවීමට හෝ කම්බි හරහා යැවීමට අදහස් කරන දත්ත සඳහා ඒවා ප්‍රයෝජනවත් වේ.

යැපෙන යතුරු ලියනයක පොකුරක් නිරාවරණය කරන ගතිලක්ෂණ සැකිලි වැනි විවිධ මෙට්‍රොප්‍රොග්‍රැමිං කාර්යයන් සඳහා ව්‍යුහයන් ද පහසු ය:

template <typename T> struct type_traits {
  typedef T type;
  typedef T::iterator_type iterator_type;
  ...
};

... නමුත් එය සැබවින්ම struct හි පෙරනිමි ආරක්ෂණ මට්ටම පොදු වීමෙන් වාසි ලබා ගැනීම පමණි ...

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

එයින් කියැවෙන්නේ, මම C # හි මෙන් C ++ හි ව්‍යුහයන් භාවිතා කිරීමට නැඹුරු වන අතර එය බ්‍රයන් පැවසූ දෙයට සමානය. ව්‍යුහයන් යනු සරල දත්ත බහාලුම් වන අතර දත්ත මත රැඳී සිටීමට අමතරව දත්ත මත ක්‍රියා කිරීමට අවශ්‍ය වස්තු සඳහා පන්ති භාවිතා කරනු ලැබේ.

ඒවා එකම දෙයකි. C ++ හි ඉන්ද්‍රජාලයට ස්තූතිවන්ත වන අතර, ව්‍යුහයකට කාර්යයන් රඳවා තබා ගැනීමට, උරුමය භාවිතා කිරීමට, "නව" භාවිතයෙන් නිර්මාණය කළ හැකිය.

එකම ක්‍රියාකාරී වෙනස වන්නේ පන්තියක් ආරම්භ වන්නේ පුද්ගලික ප්‍රවේශ අයිතිවාසිකම් සමඟ වන අතර ව්‍යුහයක් ආරම්භ වන්නේ මහජනයාගෙන් ය. සී සමඟ පසුගාමී අනුකූලතාව පවත්වා ගැනීම මෙයයි.

ප්‍රායෝගිකව, මම සෑම විටම දත්ත දරන්නන් ලෙස සහ පන්ති වස්තු ලෙස භාවිතා කර ඇත.

අනෙක් අය පෙන්වා දී ඇති පරිදි

• පෙරනිමි දෘශ්‍යතාවයට අමතරව දෙකම සමාන වේ
• ඕනෑම හේතුවක් නිසා එකක් හෝ වෙනත් එකක් භාවිතා කිරීමට බල කිරීමට හේතු තිබිය හැකිය

Stroustrup / Sutter වෙතින් භාවිතා කළ යුත්තේ කවදාද යන්න පිළිබඳ පැහැදිලි නිර්දේශයක් ඇත:

පන්තියට වෙනස්කමක් තිබේ නම් පන්තිය භාවිතා කරන්න; දත්ත සාමාජිකයින්ට ස්වාධීනව වෙනස් විය හැකි නම් struct භාවිතා කරන්න

කෙසේ වෙතත්, ඉදිරියට ප්‍රකාශයට පත් කිරීම wise ානවන්ත නොවන බව මතක තබා ගන්න. පංතියක් ලෙස ( class X;) සහ එය struct ( struct X { ... }) ලෙස අර්ථ දක්වන්න . එය සමහර සම්බන්ධක (උදා: g ++) මත ක්‍රියා කළ හැකි අතර අනෙක් ඒවා මත අසමත් විය හැකිය (උදා: MSVC), එබැවින් ඔබ සංවර්ධක නිරයේ සිටිනු ඇත.

පන්තිය.

පන්ති සාමාජිකයන් පෙරනිමියෙන් පුද්ගලිකයි.

class test_one {
    int main_one();
};

සමාන වේ

class test_one {
  private:
    int main_one();
};

එබැවින් ඔබ උත්සාහ කරන්නේ නම්

int two = one.main_one();

අපට දෝෂයක් ලැබෙනු ඇත: main_one is privateඑයට ප්‍රවේශ විය නොහැකි නිසා. එය මහජනතාව විසින් නියම කිරීමෙන් එය ආරම්භ කිරීමෙන් අපට එය විසඳිය හැකිය

class test_one {
  public:
    int main_one();
};

ව්යුහය.

Struct යනු පෙරනිමියෙන් සාමාජිකයන් පොදු වන පන්තියකි.

struct test_one {
    int main_one;
};

ක්‍රම main_oneපුද්ගලිකයි

class test_one {
  public:
    int main_one;
};

සාමාජිකයින්ට ඕනෑම වටිනාකමක් ලබා ගත හැකි දත්ත ව්‍යුහයන් සඳහා මම ව්‍යුහයන් භාවිතා කරමි, එය ඒ ආකාරයෙන් පහසුය.

structඉක්මවා යාමේ වාසියක් classනම්, එය “පළමු මහජන සාමාජිකයින්ට අනුගත වුවහොත් පුද්ගලිකයි” යනුවෙන් එක් කේත පේළියක් ඉතිරි කිරීමයි. මෙම ආලෝකයේ දී, මට යතුරු පදය නිෂ් class.ල ය.

පමණක් structසහ කිසි විටෙකත් භාවිතා කිරීමට තවත් හේතුවක් මෙන්න class. C ++ සඳහා සමහර කේත ශෛලීය මාර්ගෝපදේශ යෝජනා කරන්නේ ශ්‍රිත මැක්‍රෝස් සඳහා කුඩා අක්ෂර භාවිතා කිරීමයි, තාර්කිකත්වය නම් සාර්ව පේළිගත ශ්‍රිතයක් බවට පරිවර්තනය කළ විට නම වෙනස් කිරීම අවශ්‍ය නොවන බවයි. මෙහෙත් එහෙමයි. ඔබට ඔබේ ලස්සන සී-ස්ටයිල් ව්‍යුහයක් ඇති අතර එක් දිනක්, ඔබට ඉදිකිරීම්කරුවෙකු හෝ යම් පහසුවක් එකතු කළ යුතු බව ඔබ සොයා ගනී. ඔබ එය a ට වෙනස් classකරනවාද? සෑම තැනකම?

structS සහ classes අතර වෙනස හඳුනා ගැනීම ඕනෑවට වඩා කරදරයක් වන අතර, අප විසින් කළ යුතු දේ කිරීමේ ක්‍රමයට පිවිසීම - ක්‍රමලේඛනය. සී ++ හි බොහෝ ගැටලු මෙන්ම, එය පැන නගින්නේ පසුගාමී අනුකූලතාව සඳහා ඇති දැඩි ආශාවෙනි.

ඒවා විවිධ පෙරනිමි සමඟ එකම දේ වේ (පෙරනිමියෙන් පුද්ගලිකයි class, සහ පෙරනිමියෙන් පොදුයි struct), එබැවින් න්‍යායිකව ඒවා සම්පූර්ණයෙන්ම එකිනෙකට හුවමාරු වේ.

එබැවින්, මට යම් තොරතුරක් එහා මෙහා ගෙනයාමට අවශ්‍ය නම්, මම ක්‍රම කිහිපයක් එහි දැමුවද (නමුත් බොහෝ නොවේ) මම ව්‍යුහයක් භාවිතා කරමි. එය බොහෝ දුරට පාරදෘශ්‍ය දෙයක් නම්, ප්‍රධාන භාවිතය ක්‍රමවේදයන් හරහා වන අතර දත්ත සාමාජිකයින්ට කෙලින්ම නොවේ නම්, මම සම්පූර්ණ පන්තියක් භාවිතා කරමි.

පෙරනිමියෙන් ව්‍යුහයන්ට පොදු ප්‍රවේශයක් ඇති අතර පෙරනිමියෙන් පන්තිවලට පුද්ගලික ප්‍රවේශයක් ඇත.

පුද්ගලිකව මම දත්ත හුවමාරු වස්තු සඳහා හෝ වටිනාකම් වස්තු ලෙස ව්‍යුහයන් භාවිතා කරමි. වෙනත් කේතයන් වෙනස් කිරීම වැළැක්වීම සඳහා මම සියලුම සාමාජිකයන් කොන්ස් ලෙස ප්‍රකාශ කරමි.

දෘශ්‍යතාවයට වෙනස් පෙරනිමි සහිත වුවත්, දෙකම එක structහා classසමාන වේ, structපෙරනිමිය පොදු වන අතර classපෙරනිමිය පුද්ගලික වේ. privateසහ public. සහ සුදුසු භාවිතයෙන් ඔබට එකක් වෙනස් කළ හැකිය . ඔවුන් දෙදෙනාම උරුමය, ක්‍රම, ඉදිකිරීම්කරුවන්, විනාශ කරන්නන් සහ වස්තු නැඹුරු භාෂාවක ඉතිරි සියලු යහපත් දේවලට ඉඩ දෙයි.

කෙසේ වෙතත්, මේ දෙක අතර ඇති එක් විශාල වෙනසක් structනම්, සී හි යතුරු පදයක් සහය දක්වන නමුත් classඑසේ නොවේ. මෙම එක් භාවිත කළ හැකි ක්රම structඇතුලත් ගොනුව භාවිතයට ගත හැකි බව #includeබොහෝ කාලයක් ලෙස C ++ හෝ C එක්කෝ structතැනිතලාවක් සී රටාවකි structගොනුව වැනි සී, එනම් කිසිදු C ++ විශේෂිත ප්රධාන වචන සමග අනුකූල වේ, ඇතුලත් හා අන් සියල්ල private, publicනෑ, ක්‍රම, උරුමයක් නැත, ආදිය.

AC විලාසිතාව structවෙනත් අතුරුමුහුණත් සමඟ භාවිතා කළ හැකි අතර එය C ශෛලිය භාවිතා කරමින් structදත්ත අතුරු මුහුණත හරහා ඉදිරියට ගෙන යයි.

AC ශෛලිය structයනු මතක ප්‍රදේශයක පිරිසැලසුම විස්තර කරන ආකාරයේ අච්චුවකි (C ++ අච්චුවක් නොව රටාවක් හෝ ස්ටෙන්සිල්). වසර ගණනාවක් තිස්සේ සී සහ සී ප්ලග්-ඉන් සමඟ භාවිතා කළ හැකි අතුරුමුහුණත් (මෙන්න ඔබ දෙස බලන්නේ ජාවා සහ පයිතන් සහ විෂුවල් බේසික්) ඒවායින් සමහරක් සී ශෛලිය සමඟ ක්‍රියා කරයි struct.

C ++ හි තාක්ෂණික වශයෙන් දෙකම එක හා සමානයි - නිදසුනක් ලෙස ව්‍යුහයකට අධික ලෙස ක්‍රියාකරවන්නන් සිටිය හැකිය.

කෙසේවෙතත් :

මම විවිධ වර්ගවල තොරතුරු එකවර යැවීමට කැමති විට මම ව්‍යුහයන් භාවිතා කරමි. මම “ක්‍රියාකාරී” වස්තුවක් සමඟ ගනුදෙනු කරන විට පන්ති භාවිතා කරමි.

එය උපකාරී වේ යැයි සිතමි.

#include <string>
#include <map>
using namespace std;

struct student
{
    int age;
    string name;
    map<string, int> grades
};

class ClassRoom
{
    typedef map<string, student> student_map;
  public :
    student getStudentByName(string name) const 
    { student_map::const_iterator m_it = students.find(name); return m_it->second; }
  private :
    student_map students;
};

නිදසුනක් ලෙස, මම ව්‍යුහගත ශිෂ්‍යයෙකුට නැවත ලබා ගැනීමේ ... () ක්‍රම නැවත ලබා දෙන්නෙමි - විනෝද වන්න.

ඔබ struct භාවිතා කිරීමට තෝරා ගන්නේ කවදාද සහ C ++ හි පන්තිය භාවිතා කරන්නේ කවදාද?

මම structනිර්වචනය කරන විට functorsසහ භාවිතා කරමි POD. නැතිනම් මම භාවිතා කරමි class.

// '()' is public by default!
struct mycompare : public std::binary_function<int, int, bool>
{
    bool operator()(int first, int second)
    { return first < second; }
};

class mycompare : public std::binary_function<int, int, bool>
{
public:
    bool operator()(int first, int second)
    { return first < second; }
};

මට POD වර්ගය හෝ ෆන්ක්ටර් සෑදීමට අවශ්‍ය වූ විට මම ව්‍යුහයන් භාවිතා කරමි.

සියලුම පන්ති සාමාජිකයන් පෙරනිමියෙන් පුද්ගලික වන අතර සියලුම ව්‍යුහාත්මක සාමාජිකයන් පෙරනිමියෙන් පොදු වේ. පන්තියට සුපුරුදු පුද්ගලික පදනම් ඇති අතර ව්‍යුහයට පෙරනිමි පොදු පදනම් ඇත. C හි ව්‍යුහයට සාමාජික ශ්‍රිත තිබිය නොහැකි අතර C ++ හි මෙන් අපට සාමාජික ශ්‍රිත ව්‍යුහයට එකතු කළ හැකිය. මෙම වෙනස්කම් හැරුණු විට, මම ඔවුන් ගැන පුදුම වන කිසිවක් සොයාගෙන නැත.

මම struct භාවිතා කරන්නේ කිසියම් සාමාජික කාර්යයක් නොමැතිව (සාමාජික දත්ත මත ක්‍රියාත්මක වීමට) සහ දත්ත විචල්‍යයන්ට කෙලින්ම ප්‍රවේශ වීමට අවශ්‍ය වූ විට පමණි.

උදා: ලිපිගොනු සහ සොකට් ධාරාවන්ගෙන් දත්ත කියවීම / ලිවීම යනාදිය.

පෙරනිමි ප්‍රවේශය හැර තාක්ෂණික වශයෙන් පන්තිය සහ නූල් අතර විශාල වෙනසක් නොමැත. ඊට වඩා වැඩි ප්‍රමාණයක් ඔබ එය භාවිතා කරන ආකාරය ක්‍රමලේඛන විලාසය මත රඳා පවතී.

ව්‍යුහයන් යනු දත්ත ව්‍යුහයක් ලෙස (බහු-දත්ත වර්ගයේ තොරතුරු සමූහයක් වැනි) අදහස් කර ඇති බවත්, කේත ඇසුරුම්කරණය සඳහා පන්ති යෙදී ඇති බවත් (උපසිරැසි සහ ක්‍රියාකාරකම් එකතු කිරීම වැනි) මම සිතුවෙමි.

:(

මම කිසි විටෙකත් C ++ හි "struct" භාවිතා නොකරමි.

ඔබ හිතාමතාම ව්‍යාකූල වීමට උත්සාහ නොකරන්නේ නම්, ඔබට පෞද්ගලික සාමාජිකයන් අවශ්‍ය වූ විට ඔබ ව්‍යුහයක් භාවිතා කරන අවස්ථාවක් මට සිතාගත නොහැකිය.

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

උදා

class PublicInputData {
    //data members
 };