การใช้งาน std::vector ที่มีอยู่ในตัวเองและเข้ากันได้กับ STL

ผู้ที่อยู่เบื้องหลังไลบรารี Eigen ดูเหมือนจะพบวิธีแก้ปัญหาที่ดีสำหรับปัญหาการจัดเก็บ "ประเภทที่จัดชิดเกินไป" (ดังที่ Stephan T. Lavavej เรียกพวกเขา) ลงใน std::vector ตามที่นำมาใช้ใน STL ของ Visual Studio

การใช้งานดูเหมือนซับซ้อนโดยไม่จำเป็น (ตรวจสอบแหล่งที่มาที่นี่ และ ที่นี่) แต่แนวคิดหลักคือการสรุปประเภทที่เข้าสู่ std::vector ด้วย กระดาษห่อบาง:

#include <vector>

template <typename T>
struct wrapper : public T
{
    wrapper() {}
    wrapper(const T& rhs) : T(rhs) {}
};

struct __declspec(align(64)) S
{
    float x, y, z, w;
};

int main()
{
    std::vector< wrapper<S> > v;  // OK, no C2719 error
    return 0;
}

ส่วนเรื่องการใช้งานใน Eigen ก็ต้องยอมรับว่าไม่ค่อยเข้าใจ

• ทำไมพวกเขาต้องการ Eigen::aligned_allocator_indirection,
• เหตุใดจึงต้องยกเว้นประเภทเลขคณิตใน EIGEN_WORKAROUND_MSVC_STL_SUPPORT
• เหตุใดพวกเขาจึงต้องกำหนดตัวสร้างและตัวดำเนินการเหล่านี้ทั้งหมดใน Eigen::workaround_msvc_stl_support
• หรือเหตุใดพวกเขาจึงต้องกำหนด resize ใหม่ในความเชี่ยวชาญเฉพาะทางบางส่วนของ std::vector สำหรับการจัดสรร Eigen::aligned_allocator_indirection...

ยินดีต้อนรับเบาะแส ประเด็นก็คือ เคล็ดลับนี้ใช้งานได้อย่างสมบูรณ์แบบ (เท่าที่ฉันสามารถบอกได้) และฉันไม่เห็นอะไรผิดปกติ นอกเหนือจากความไม่สง่างามเล็กน้อย

ตัวเลือกที่ง่ายที่สุด (และดีที่สุด imho) คือการจัดหาฟังก์ชันฟรีเป็นส่วนขยายของอินเทอร์เฟซ vector ซึ่งทำสิ่งที่ถูกต้อง ฟังก์ชั่นที่คุณต้องใช้ resize นั้นมีให้ใช้งานจากอินเทอร์เฟซสาธารณะของ std::vector:

#include <vector>

template<class T, class Alloc>
void resize(std::vector<T, Alloc>& v,
    typename std::vector<T, Alloc>::size_type new_size, T const& val)
{
  if (v.size() < new_size)
      v.insert(v.end(), new_size - v.size(), val);
  else if (new_size < v.size())
      v.erase(v.begin() + new_size, v.end());
}

และเพื่อความสอดคล้องกันก็มีเวอร์ชันอาร์กิวเมนต์เดียวด้วย:

template<class T, class Alloc>
void resize(std::vector<T, Alloc>& v,
    typename std::vector<T, Alloc>::size_type new_size)
{
    v.resize(new_size); // simply forward
}

อย่างไรก็ตาม หากคุณเพียงต้องการดรอปอินเวกเตอร์ใหม่และไม่ต้องกังวลกับฟังก์ชันฟรีหรือสมาชิก อีกทางเลือกหนึ่งก็คือคลาสย่อย std::vector:

#include <vector>
#include <memory>

template<class T, class Alloc = std::allocator<T>>
class myvector
  : public std::vector<T, Alloc>
{
  typedef std::vector<T, Alloc> base;
public:
  typedef typename base::size_type size_type;

  void resize(size_type new_size){
    base::resize(new_size);
  }

  void resize(size_type new_size, T const& val){
    if (this->size() < new_size)
        this->insert(this->end(), new_size - this->size(), val);
    else if (new_size < this->size())
        this->erase(this->begin() + new_size, this->end());
  }
};

โปรดทราบว่าฉันยังจัดเตรียมเวอร์ชันอาร์กิวเมนต์เดียวของ resize เนื่องจากเวอร์ชันอาร์กิวเมนต์ทั้งสองจะซ่อนเวอร์ชันคลาสฐานทั้งหมด โปรดทราบว่าฉันต้องเติมคำนำหน้าการเรียกฟังก์ชันสมาชิกทั้งหมดด้วย this-> เนื่องจากสิ่งเหล่านั้นขึ้นอยู่กับคลาสพื้นฐาน std::vector และด้วยอาร์กิวเมนต์เทมเพลต