טופלים ב- C ++

טופל הוא אובייקט שיכול להחזיק מספר אלמנטים. האלמנטים יכולים להיות מסוגי נתונים שונים. אלמנטים של טופלים מאתחלים כטיעונים לפי הסדר בהם יגיעו אליהם.  טופלים הם מבנה נתונים רב -תכליתי לקיבוץ ערכי. כדי להבין כיצד להשתמש בפיצולים ב- C ++ וביישומים שלהם C ++ קורס מספק הדרכות ודוגמאות מקיפות.

פעולות ב- TUPLE

1. קבל (): GET () משמש לגישה לערכי TUPLE ולשנות אותם הוא מקבל את שם האינדקס ושם TUPLE כטיעונים כדי לגשת לאלמנט TUPLE מסוים. 

2. Make_tuple (): make_tuple () משמש להקצאת Tuple עם ערכים. הערכים שעברו צריכים להיות כדי להיות עם הערכים המוכרזים ב- TUPLE. 

CPP
   #include          #include         using     namespace     std  ;   int     main  ()     {          // Declaring tuple      tuple   <  char       int       float  >     geek  ;      // Assigning values to tuple using make_tuple()      geek     =     make_tuple  (  'a'       10       15.5  );      // Printing initial tuple values using get()      cout      < <     'The initial values of tuple are: '  ;      cout      < <     get   <  0  >  (  geek  )      < <     ' '      < <     get   <  1  >  (  geek  );      cout      < <     ' '      < <     get   <  2  >  (  geek  )      < <     endl  ;      // Use of get() to change values of tuple      get   <  0  >  (  geek  )     =     'b'  ;      get   <  2  >  (  geek  )     =     20.5  ;      // Printing modified tuple values      cout      < <     'The modified values of tuple are: '  ;      cout      < <     get   <  0  >  (  geek  )      < <     ' '      < <     get   <  1  >  (  geek  );      cout      < <     ' '      < <     get   <  2  >  (  geek  )      < <     endl  ;      return     0  ;   }   

תְפוּקָה
The initial values of tuple are: a 10 15.5 The modified values of tuple are: b 10 20.5  

הֶסבֵּר : בקוד לעיל GET () משנה את הערך הראשון וה -3 של TUPLE. 

3. Tuple_size: זה מחזיר את מספר האלמנטים הקיימים בטפל. 

CPP
   #include          #include         using     namespace     std  ;   int     main  ()     {          // Initializing tuple      tuple   <  char       int       float  >     geek  (  20       'g'       17.5  );      // Use of size to find tuple_size of tuple      cout      < <     'The size of tuple is: '  ;      cout      < <     tuple_size   <  decltype  (  geek  )  >::  value  ;      return     0  ;   }   

תְפוּקָה
The size of tuple is: 3 

4. החלפה (): ההחלפה () מחליפה את האלמנטים של שני המפלים השונים.

CPP
   #include          #include         using     namespace     std  ;   int     main  ()     {          // Initializing 1st tuple      tuple   <  int       char       float  >     tup1  (  20       'g'       17.5  );      // Initializing 2nd tuple      tuple   <  int       char       float  >     tup2  (  10       'f'       15.5  );      // Printing 1st and 2nd tuple before swapping      cout      < <     'The first tuple elements before swapping are: '  ;      cout      < <     get   <  0  >  (  tup1  )      < <     ' '      < <     get   <  1  >  (  tup1  )      < <     ' '      < <     get   <  2  >  (  tup1  )      < <     endl  ;      cout      < <     'The second tuple elements before swapping are: '  ;      cout      < <     get   <  0  >  (  tup2  )      < <     ' '      < <     get   <  1  >  (  tup2  )      < <     ' '      < <     get   <  2  >  (  tup2  )      < <     endl  ;      // Swapping tup1 values with tup2      tup1  .  swap  (  tup2  );      // Printing 1st and 2nd tuple after swapping      cout      < <     'The first tuple elements after swapping are: '  ;      cout      < <     get   <  0  >  (  tup1  )      < <     ' '      < <     get   <  1  >  (  tup1  )      < <     ' '      < <     get   <  2  >  (  tup1  )      < <     endl  ;      cout      < <     'The second tuple elements after swapping are: '  ;      cout      < <     get   <  0  >  (  tup2  )      < <     ' '      < <     get   <  1  >  (  tup2  )      < <     ' '      < <     get   <  2  >  (  tup2  )      < <     endl  ;      return     0  ;   }   


תְפוּקָה

 The first tuple elements before swapping are: 20 g 17.5   
The second tuple elements before swapping are: 10 f 15.5
The first tuple elements after swapping are: 10 f 15.5
The second tuple elements after swapping are: 20 g 17.5

5. עניבה () : עבודת העניבה () היא לפרוק את ערכי הטפל למשתנים נפרדים. ישנן שתי גרסאות של עניבה () עם ובלי 'להתעלם' ה"תעלם "מתעלם מאלמנט טפל מסוים ומונע ממנו להתנתק.

CPP
   #include          #include         // for tie() and tuple   using     namespace     std  ;   int     main  ()     {         // Initializing variables for unpacking      int     i_val  ;      char     ch_val  ;      float     f_val  ;             // Initializing tuple      tuple   <  int       char       float  >     tup1  (  20       'g'       17.5  );      // Use of tie() without ignore      tie  (  i_val       ch_val       f_val  )     =     tup1  ;          // Displaying unpacked tuple elements without ignore      cout      < <     'The unpacked tuple values (without ignore) are: '  ;      cout      < <     i_val      < <     ' '      < <     ch_val      < <     ' '      < <     f_val  ;      cout      < <     endl  ;          // Use of tie() with ignore      // ignores char value      tie  (  i_val       ignore       f_val  )     =     tup1  ;          // Displaying unpacked tuple elements with ignore      cout      < <     'The unpacked tuple values (with ignore) are: '  ;      cout      < <     i_val      < <     ' '      < <     f_val  ;      cout      < <     endl  ;      return     0  ;   }   

תְפוּקָה
The unpacked tuple values (without ignore) are: 20 g 17.5 The unpacked tuple values (with ignore) are: 20 17.5  

6. tuple_cat (): פונקציה זו משרתת שני טופלים ומחזירה טופלה חדשה. 

CPP
   #include          #include         // for tuple_cat() and tuple   using     namespace     std  ;   int     main  ()     {      // Initializing 1st tuple      tuple   <  int       char       float  >     tup1  (  20       'g'       17.5  );      // Initializing 2nd tuple      tuple   <  int       char       float  >     tup2  (  30       'f'       10.5  );          // Concatenating 2 tuples to return a new tuple      auto     tup3     =     tuple_cat  (  tup1       tup2  );          // Displaying new tuple elements      cout      < <     'The new tuple elements in order are: '  ;      cout      < <     get   <  0  >  (  tup3  )      < <     ' '      < <     get   <  1  >  (  tup3  )      < <     ' '          < <     get   <  2  >  (  tup3  )      < <     ' '      < <     get   <  3  >  (  tup3  )      < <     ' '          < <     get   <  4  >  (  tup3  )      < <     ' '      < <     get   <  5  >  (  tup3  )      < <     endl  ;      return     0  ;   }   

תְפוּקָה
The new tuple elements in order are: 20 g 17.5 30 f 10.5