Miseryk

C++ Vector Vs List The Mith

Jan 26th, 2021 (edited)
421
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. //VS 2019 Pro
  2. #include <iostream>
  3. #include <Windows.h>
  4. #include <vector>
  5. #include <list>
  6.  
  7. /*
  8. Spoiler: Vector is best always
  9. */
  10.  
  11. enum eMode
  12. {
  13.     eVector,
  14.     eList
  15. };
  16.  
  17. eMode ArrayMode;
  18.  
  19. void PushAmount(std::vector<int>& vVector, std::list<int>& vList, DWORD vSize)
  20. {
  21.     switch (ArrayMode)
  22.     {
  23.         case eMode::eVector:
  24.             for (DWORD i = 0; i < vSize; i++)
  25.             {
  26.                 vVector.push_back(i);
  27.             }
  28.  
  29.             break;
  30.         case eMode::eList:
  31.             for (DWORD i = 0; i < vSize; i++)
  32.             {
  33.                 vList.push_back(i);
  34.             }
  35.  
  36.             break;
  37.         default:
  38.             break;
  39.     }
  40. }
  41.  
  42. void Erase_By1_position(std::vector<int>& vVector, std::list<int>& vList, double vIndexPercent, DWORD vTimes, BOOL Enhancement = FALSE)
  43. {
  44.     std::list<int>::iterator it1;
  45.     int mid;
  46.  
  47.     switch (ArrayMode)
  48.     {
  49.         case eMode::eVector:
  50.             for (int i = vTimes; i > 0; i--)
  51.             {
  52.                 if (vIndexPercent == 0)
  53.                 {
  54.                     if (Enhancement)
  55.                     {
  56.                         //Insert Magic Here
  57.                     }
  58.                     else
  59.                     {
  60.                         vVector.erase(vVector.begin());
  61.                     }
  62.                 }
  63.                 else
  64.                 {
  65.                     if (vIndexPercent == 1)
  66.                     {
  67.                         vVector.erase(vVector.end() - 1);
  68.                     }
  69.                     else
  70.                     {
  71.                         if (Enhancement)
  72.                         {
  73.                             //Insert Magic Here
  74.                         }
  75.                         else
  76.                         {
  77.                             mid = (int)((vVector.size() - 1) * vIndexPercent);
  78.                             vVector.erase(vVector.begin() + mid);
  79.                         }
  80.                     }
  81.                 }
  82.             }
  83.  
  84.             break;
  85.         case eMode::eList:
  86.             for (int i = vTimes; i > 0; i--)
  87.             {
  88.                 if (vIndexPercent == 0)
  89.                 {
  90.                     vList.pop_front(); //tList.erase(tList.begin());
  91.                 }
  92.                 else
  93.                 {
  94.                     if (vIndexPercent == 1)
  95.                     {
  96.                         it1 = vList.end();
  97.                         --it1;
  98.                         vList.erase(it1);
  99.                     }
  100.                     else
  101.                     {
  102.                         it1 = vList.begin();
  103.                         mid = (int)((vList.size() - 1) * vIndexPercent);
  104.                         std::advance(it1, mid);
  105.                         vList.erase(it1);
  106.                     }
  107.                 }
  108.             }
  109.  
  110.             break;
  111.         default:
  112.             break;
  113.     }
  114. }
  115.  
  116. int main()
  117. {
  118.     ArrayMode = eMode::eVector;
  119.  
  120.     std::list<int> tList;
  121.     std::vector<int> tVec;
  122.  
  123.     std::cin.get();
  124.  
  125.     DWORD GTC = GetTickCount();
  126.  
  127.     DWORD zSize = 0x05000000; //0x05000000;
  128.  
  129.     PushAmount(tVec, tList, zSize);
  130.  
  131.     if (tList.size() > 0) std::cout << tList.size() << " => " << GetTickCount() - GTC << std::endl;
  132.     if (tVec.size() > 0) std::cout << tVec.size() << " => " << GetTickCount() - GTC << std::endl;
  133.    
  134.     int TotSize = zSize / 0x010000;
  135.  
  136.     /* 0%
  137.     Vector:
  138.                 83886080 => 359
  139.                 83884800 => 48187
  140.  
  141.             Enhancement
  142.                 83886080 => 312
  143.                 83884800 => 312
  144.     List:
  145.                 83886080 => 4156
  146.                 83884800 => 4156
  147.     */
  148.     Erase_By1_position(tVec, tList, 0, TotSize);
  149.  
  150.     /* 3%
  151.     Vector:
  152.                 83886080 => 359
  153.                 83884800 => 48343
  154.  
  155.             Enhancement
  156.                 83886080 => 313
  157.                 83884800 => 1938
  158.     List:
  159.                 83886080 => 4156
  160.                 83884800 => 14203
  161.     */
  162.     //Erase_By1_position(tVec, tList, 0.03, TotSize);
  163.  
  164.     /* 5%
  165.     Vector:
  166.                 83886080 => 344
  167.                 83884800 => 46078
  168.  
  169.             Enhancement
  170.                 83886080 => 312
  171.                 83884800 => 3015
  172.     List:
  173.                 83886080 => 4234
  174.                 83884800 => 20719
  175.     */
  176.     //Erase_By1_position(tVec, tList, 0.05, TotSize);
  177.  
  178.     /* 10%
  179.     Vector:
  180.                 83886080 => 344
  181.                 83884800 => 43922
  182.  
  183.             Enhancement
  184.                 83886080 => 313
  185.                 83884800 => 5688
  186.     List:
  187.                 83886080 => 4218
  188.                 83884800 => 37797
  189.     */
  190.     //Erase_By1_position(tVec, tList, 0.10, TotSize);
  191.  
  192.     /* 15%
  193.     Vector:
  194.                 83886080 => 344
  195.                 83884800 => 42000
  196.  
  197.             Enhancement
  198.                 83886080 => 312
  199.                 83884800 => 8218
  200.     List:
  201.                 83886080 => 4281
  202.                 83884800 => 53140
  203.     */
  204.     //Erase_By1_position(tVec, tList, 0.15, TotSize);
  205.  
  206.     /* 25%
  207.     Vector:
  208.                 83886080 => 328
  209.                 83884800 => 35375
  210.  
  211.             Enhancement
  212.                 83886080 => 313
  213.                 83884800 => 13657
  214.     List:
  215.                 83886080 => 4125
  216.                 83884800 => 84859
  217.     */
  218.     //Erase_By1_position(tVec, tList, 0.25, TotSize);
  219.  
  220.     /* 45%
  221.     Vector:
  222.                 83886080 => 312
  223.                 83884800 => 25640
  224.  
  225.             Enhancement
  226.                 83886080 => 328
  227.                 83884800 => 24188
  228.     List:
  229.                 83886080 => 4078
  230.                 83884800 => 147860
  231.     */
  232.     //Erase_By1_position(tVec, tList, 0.45, TotSize);
  233.  
  234.     /* 50%
  235.     Vector:
  236.                 83886080 => 375
  237.                 83884800 => 23812
  238.  
  239.             Enhancement
  240.                 83886080 => 312
  241.                 83884800 => 23406
  242.     List:
  243.                 83886080 => 4468
  244.                 83884800 => 172062
  245.     */
  246.     //Erase_By1_position(tVec, tList, 0.50, TotSize);
  247.  
  248.     /* 75%
  249.     Vector:
  250.                 83886080 => 359
  251.                 83884800 => 12218
  252.  
  253.             Enhancement
  254.                 83886080 => 328
  255.                 83884800 => 11953
  256.     List:
  257.                 83886080 => 4204
  258.                 83884800 => 239954
  259.     */
  260.     //Erase_By1_position(tVec, tList, 0.75, TotSize);
  261.  
  262.     /* 85%
  263.     Vector:
  264.                 83886080 => 313
  265.                 83884800 => 7282
  266.  
  267.             Enhancement
  268.                 83886080 => 313
  269.                 83884800 => 7204
  270.     List:
  271.                 83886080 => 4157
  272.                 83884800 => 280016
  273.     */
  274.     //Erase_By1_position(tVec, tList, 0.85, TotSize);
  275.  
  276.     /* 95%
  277.     Vector:
  278.                 83886080 => 312
  279.                 83884800 => 2609
  280.  
  281.             Enhancement
  282.                 83886080 => 312
  283.                 83884800 => 2609
  284.     List:
  285.                 83886080 => 4094
  286.                 83884800 => 295234
  287.     */
  288.     //Erase_By1_position(tVec, tList, 0.95, TotSize);
  289.  
  290.     /* 100%
  291.     Vector:
  292.                 83886080 => 312
  293.                 83884800 => 312
  294.  
  295.             Enhancement
  296.                 83886080 => 313
  297.                 83884800 => 313
  298.     List:
  299.                 83886080 => 4109
  300.                 83884800 => 4109
  301.     */
  302.     //Erase_By1_position(tVec, tList, 1, TotSize);
  303.  
  304.     if (tList.size() > 0)
  305.     {
  306.         std::cout << std::dec << tList.size() << " => " << GetTickCount() - GTC << std::endl;
  307.  
  308.         std::list<int>::iterator it_begin = tList.begin();
  309.         std::list<int>::iterator it_last = tList.end();
  310.         --it_last;
  311.         std::cout << *it_begin << " - " << *it_last << std::endl;
  312.     }
  313.  
  314.     if (tVec.size() > 0)
  315.     {
  316.         std::cout << std::dec << tVec.size() << " => " << GetTickCount() - GTC << std::endl;
  317.        
  318.         std::cout << tVec[0] << " - " << tVec[tVec.size() - 1] << std::endl;
  319.         /*for (int i = 0; i < tVec.size(); i++)
  320.         {
  321.             std::cout << tVec[i] << " - ";
  322.         }*/
  323.     }
  324.    
  325.     std::cin.get();
  326.  
  327.     std::cout << "clearing and shrinking" << std::endl;
  328.     tVec.clear();
  329.     tVec.shrink_to_fit();
  330.  
  331.     std::cin.get();
  332.  
  333.     return 0;
  334. }
RAW Paste Data