Question

这是我的代码：

template<typename B>
class cvector{

public:

    cvector(){    
    allocatedSize =0;
    actualSize = 0;
    buffer = 0;
    }


    cvector(int k):allocatedSize(k){

    }


    cvector(int k, const B& initial ):allocatedSize(k), actualSize(k){

    buffer = new B[allocatedSize];

        for(int i = 0;i<allocatedSize;i++){
            buffer[i] = initial;
        }   
    }

    ~cvector(){
        delete [] buffer;                   
    }


private:
    int allocatedSize;
    int actualSize;
    B* buffer;

};

int main(int argc, char** argv) {

cvector<int> pee(2,int(5));
cvector<int*> kay(2,new int(10));
return 0;
}

我想模仿std::vector。我的代码没有优化和干净，因为这只是一个草稿，但截至目前，我没有遇到任何问题，这是我初始化时的测试用例：

cvector<int> p(2,int(5));                   //no error
cvector<int*> k(2,new int(10));             //no error
cvector<int> j(2,new int(5));               // error because it's int
cvector<int*> l(2,int(2));                  //error because it's a pointer

我很好奇如果我将B或int放入这些int*表达式？

B* buffer;                           // (int*)* so int *? (just like reference collapsing?
buffer = new B[allocatedSize];       // new int* if int* ?!

因此，如果我使用int*，那么B* buffer;将是int*？我的代码中的buffer = new B[allocatedSize];和const B& initial呢？

Answer 1

“指针崩溃”不存在不会添加或删除任何星星或其他任何东西。

B* buffer;
buffer = new B[allocatedSize];

B为int会导致

int* buffer;
buffer = new int[allocatedSize];

即。一个int的数组，你可以用int做任何你想做的事。

B为int*，它将是

int** buffer;
buffer = new int*[allocatedSize];

即。一个int指针数组，所有指针都指向无处（最初），
你可以用你的指针做任何你想做的事。

Answer 2

如果我将int或int *？
放入，这些B表达式如何评估

对于int，B将为int*，对于int*，B将为int**。

所以，如果我将使用int *然后B *缓冲区;将是int *？怎么样的缓冲区 = new B [allocatedSize];我的代码中有const B& initial？

没有。如上所述，B*将为int**。对于int*，表达式如下：

(int**)buffer = new int*[allocatedSize];

const B& initial将被评估为const int*&。

根据我的建议，对于生产代码，您可能会认为上面有std::vector作为对象而cvector作为它的包装。或者以"has a"关系从cvector继承std::vector。

在模板类中折叠指针？

2 个答案: