C ++編譯器如何擴展template <>代碼，並且如何影響它們的速度？

Question

我對模板以及編譯器如何處理它們幾乎不知所措。

需要std :: vector << SomeType * >> * lpVars的通用包裝器； 當我刪除lpVars時，能夠對該向量中包含的所有項目執行刪除操作。 與C＃的List <>（通用列表類）相似。 所以我去了模板，並寫了這樣的東西：

template<class T>
class ListPtr
{
public:
  std::vector<T*> items;
  ListPtr()
  { }
  ~ListPtr()
  {
    size_t count = items.size();
    for(size_t i=0; i<count; i++)
    {
      T* item = items[i];
      delete item;
    }
    items.clear();
  }
  inline const int count() const
  {
    return (int)items.size();
  }
  inline T* operator[](size_t index) const
  {
    return items[index];
  }
  inline void Add(T* item)
  {
    items.push_back(item);
  }
};

后來我聲明了全局類型列表，例如：

class SomeType1List : public ListPtr<SomeType1> {};
class SomeType2List : public ListPtr<SomeType2> {};
...
class SomeTypeNList : public ListPtr<SomeTypeN> {};

這是我對主題感興趣的第一部分：

（1）是否像沒有模板（完全聲明的類）那樣，對每個聲明（SomeType1，SomeType2，...，SomeTypeN）的類SomeType1List，SomeType1List，...，SomeTypeNList進行了充分預處理，以替換了T模板類型的模板代碼，還是編譯器在這里執行其他功能？

（2）如果編譯器執行了其他魔術，那么我應該如何定義這種類型，以便它們在完全聲明的類中被編譯？

---

為了更精確地解釋上述代碼的用法：

此列表實例已初始化，並從如下函數返回：

SomeType1List* GetItems()
{
  SomeType1List* items = new SomeType1List();
  for(int i=0; i<1000; i++)
  {
    SomeType1* item = new SomeType1();
    // feed item with some data
    items->Add(item);
  }
  return items;
}

並在其他類似的代碼部分中使用：

SomeType1List* items = GetItems();
int count = items->count();
for(int i=0; i<count; i++)
{
  SomeType1* item = items[i];
  // do something with item;
}
delete items; // all memory occupied by items released after this line

我對主題的興趣的第二部分：

（3）是否可以僅使用標准類（不使用boost或類似的SDK）以不同的方式編寫？ 目標是速度，但要保持代碼的清潔和易於閱讀。 因此，這個問題是否有更好的方法來完成所有這些工作？

Answer 1

1. 是

2. 這里沒有魔術

3. 您可以使用std::vector<std::unique_ptr<T>> （C ++ 11）或std::vector<std::auto_ptr<T>> （不推薦使用）

例：

#include <iostream>
#include <memory>
#include <vector>

class T
{
private:
    unsigned int _i;

public: 
    void print() const
    {
        std::cout << "Print: " << _i << std::endl;
    }

    T(unsigned int i)
    {
        _i = i;

        std::cout << "Constructor! " << _i << std::endl;
    }

    ~T()
    {
        std::cout << "Destructor! " << _i << std::endl;
    }
};

std::vector<std::unique_ptr<T>>* createStuff()
{
    auto output = new std::vector<std::unique_ptr<T>>;

    for(unsigned int i = 0; i < 5; i++)
    {
        output->emplace_back(new T(i));
    }

    return output;
}

int main()
{
    std::cout << "Begin!" << std::endl;

    auto stuff = createStuff();

    for(std::unique_ptr<T> const& thing : *stuff)
    {
        thing->print();
    }

    delete stuff;

    std::cout << "End!" << std::endl;

    return 0;
}

輸出：

Begin!
Constructor! 0
Constructor! 1
Constructor! 2
Constructor! 3
Constructor! 4
Print: 0
Print: 1
Print: 2
Print: 3
Print: 4
Destructor! 0
Destructor! 1
Destructor! 2
Destructor! 3
Destructor! 4
End!