C++ 使用C+中的vector创建一个新的反向列表（自己的类）+；_C++_Visual Studio_C++11_Vector

C++ 使用C+中的vector创建一个新的反向列表（自己的类）+；

c++ visual-studio c++11 vector

C++ 使用C+中的vector创建一个新的反向列表（自己的类）+；,c++,visual-studio,c++11,vector,C++,Visual Studio,C++11,Vector,我有下一个代码： #include <vector> #include <string.h> #include <algorithm> #include <stdio.h> #include <tchar.h> class TList { private: std::vector<const char*> elementos; int position; TList(std::vector&l

我有下一个代码：

#include <vector>
#include <string.h>
#include <algorithm>
#include <stdio.h>
#include <tchar.h>

class TList {
private:
     std::vector<const char*> elementos;
     int position;
     TList(std::vector<const char*> elementos);
public:
    TList(const char** e, int s);
    TList *GetReverseList();
    int Size();
    const char *Next();
};

TList::TList(const char** e, int s) {
    std::vector<const char*> res (&e[0], &e[s]);
    elementos = res;
    position = 0;
}

TList::TList(std::vector<const char *> elements) {
    std::vector<const char*> res = std::vector<const char*>();
    int size = elements.size();
    for (int i = 0; i < size; i++) {
        res.push_back(elements.at(i));
    }
    elementos = res;
    position = 0;
}

//Create a new TList with the reverse list of elements
TList *TList::GetReverseList() {
    TList *res = new TList(elementos);
    std::reverse(res->elementos.begin(), res->elementos.end());
    return res;
}

int TList::Size() {
    return elementos.size();
}

//Use the position to get the next char *
const char * TList::Next() {
    const char * res;
    if (elementos.empty()) {
        res = NULL;
    }
    else {
        int pos = position;
        int size = elementos.size();
        res = pos == size ? elementos.at(position - 1) : elementos.at(position);
        if (pos < size) {
            position++;
        }
    }
    return res;
}

int main()
{
    int size = 2;
    const char *arr[2] = {"Hola", "AAAA"};
    TList *list = new TList(arr, size);
    TList *listReverse = list->GetReverseList();
    printf("Size: %u \n", listReverse->Size());
    printf("First value: %s \n", listReverse->Next());
    printf("Second value: %s \n", listReverse->Next());
    delete list;
    delete listReverse;
    return 0;
}

并引发异常“UCRTBASE.pdb not loaded”“UCRTBASE.pdb包含查找模块UCRTBASE.dll源所需的调试信息”以下是一个图像：

并打开此窗口：

所有这些异常都是在尝试删除listReverse时引发的，下面是调用堆栈的另一个捕获（忽略其他变量，如listCopy）：

我想创建一个尽可能优化的新TList，但在其元素反转的情况下，我不想创建一个复制构造函数，因为我需要它作为函数“GetReverseList”，那么，我能做什么呢？

您不应该在

TList:：TList（std:：vector elements）中使用元素作为参数元素的
已定义为类成员
以下code
可以工作：
#include <vector>
#include <string.h>
#include <algorithm>
#include <stdio.h>
#include <iostream>
//#include <tchar.h>

class TList {
private:
     std::vector<const char*> elementos;
     int position;
     TList(std::vector<const char*> elementos);
public:
    TList(const char** e, int s);
    TList *GetReverseList();
    int Size();
    const char *Next();
};

TList::TList(const char** e, int s) {
    std::vector<const char*> res (&e[0], &e[s]);
    elementos = res;
    position = 0;
}

TList::TList(std::vector<const char *> ve) {
    std::vector<const char*> res = std::vector<const char*>();
    int size = ve.size();
    for (int i = 0; i < size; i++) {
        res.push_back(ve.at(i));
    }
    elementos = res;
    position = 0;
}

//Create a new TList with the reverse list of elements
TList *TList::GetReverseList() {
    TList *res = new TList(elementos);
    std::reverse(res->elementos.begin(), res->elementos.end());
    return res;
}

int TList::Size() {
    return elementos.size();
}

//Use the position to get the next char *
const char * TList::Next() {
    const char * res;
    if (elementos.empty()) {
        res = NULL;
    }
    else {
        int pos = position;
        int size = elementos.size();
        res = pos == size ? elementos.at(position - 1) : elementos.at(position);
        if (pos < size) {
            position++;
        }
    }
    return res;
}

int main()
{
    int size = 2;
    const char *arr[2] = {"Hola", "AAAA"};
    TList *list = new TList(arr, size);
    TList *listReverse = list->GetReverseList();
    printf("Size: %u \n", listReverse->Size());
    printf("First value: %s \n", listReverse->Next());
    printf("Second value: %s \n", listReverse->Next());
    delete list;
    delete listReverse;
    return 0;
}

#包括
#包括
#包括
#包括
#包括
//#包括
类列表{
私人：
std：：向量元素；
内部位置；
TList（std:：vector elementos）；
公众：
t列表（常量字符**e，整数s）；
TList*GetReverseList（）；
int Size（）；
常量字符*Next（）；
};
TList:：TList（常量字符**e，整数s）{
std：：向量res（&e[0]，&e[s]）；
elementos=res；
位置=0；
}
TList:：TList（std:：vector ve）{
std:：vector res=std:：vector（）；
int size=ve.size（）；
对于（int i=0；ielementos.begin（），res->elementos.end（））；
返回res；
}
int-TList:：Size（）{
返回elementos.size（）；
}
//使用该位置获取下一个字符*
const char*TList:：Next（）{
常量字符*res；
if（elementos.empty（））{
res=NULL；
}
否则{
int pos=位置；
int size=elementos.size（）；
res=pos==size？elementos.at（位置-1）：elementos.at（位置）；
如果（位置<尺寸）{
位置++；
}
}
返回res；
}
int main（）
{
int size=2；
const char*arr[2]={“Hola”，“AAAA”}；
TList*列表=新的TList（arr，大小）；
TList*listReverse=list->GetReverseList（）；
printf（“大小：%u\n”，listReverse->Size（））；
printf（“第一个值：%s\n”，listReverse->Next（））；
printf（“第二个值：%s\n”，listReverse->Next（））；
删除名单；
删除列表反转；
返回0；
}
我意识到错误是不同的，因为正如我之前所评论的，主要问题是代码的“listReverse”是“listReverseOptimizada”，解析中的另一个“listReverse”是“TList”而不是“TList*”，所以当我试图删除它时，我放上了“delete&listReverse”，它抛出错误，我如何删除“TList”对象
以下是包含该元素的完整代码：
#include <vector>
#include <string.h>
#include <algorithm>
#include <stdio.h>
#include <tchar.h>

class TList {
private:
     std::vector<const char*> elementos;
     int position;
     TList(std::vector<const char*> elementos);
public:
    TList(const char** e, int s);
    TList(const TList & list);
    TList GetReverseList(TList lstSrc);
    TList *GetReverseList();
    int Size();
    const char *Next();
};

TList::TList(const char** e, int s) {
    std::vector<const char*> res (&e[0], &e[s]);
    elementos = res;
    position = 0;
}

TList::TList(std::vector<const char *> elements) {
    std::vector<const char*> res = std::vector<const char*>();
    int size = elements.size();
    for (int i = 0; i < size; i++) {
        res.push_back(elements.at(i));
    }
    elementos = res;
    position = 0;
}

TList::TList(const TList & list) {
    std::vector<const char*> el = std::vector<const char*>();
    int size = list.elementos.size();
    for (int i = 0; i < size; i++) {
        el.push_back(list.elementos[i]);
    }
    elementos = el;
    position = 0;
}

//Create a new TList * with the reverse list of elements
TList *TList::GetReverseList() {
    TList *res = new TList(elementos);
    std::reverse(res->elementos.begin(), res->elementos.end());
    return res;
}

//Create a new TList with the reverse list of elements
TList TList::GetReverseList(TList lstSrc) {
    TList *res = new TList(lstSrc);
    std::reverse(res->elementos.begin(), res->elementos.end());
    return *res;
}

int TList::Size() {
    return elementos.size();
}

//Use the position to get the next char *
const char * TList::Next() {
    const char * res;
    if (elementos.empty()) {
        res = NULL;
    }
    else {
        int pos = position;
        int size = elementos.size();
        res = pos == size ? elementos.at(position - 1) : elementos.at(position);
        if (pos < size) {
            position++;
        }
    }
    return res;
}

int main()
{
    int size = 2;
    const char *arr[2] = {"Hola", "AAAA"};
    TList *list = new TList(arr, size);
    TList listReverse = list->GetReverseList(*list);
    TList *listReverseOptimized = list->GetReverseList();
    delete list;
    delete listReverse;
    delete listReverseOptimized;
    return 0;
}

#包括
#包括
#包括
解决这个问题的合适工具是调试器。这是家庭作业还是你自己为什么要编写列表？你查过STL了吗？请不要使用原始指针（请检查）。按“重试”。然后沿着调用堆栈走到您的代码处。该代码触发了一个检查，Microsoft很大方地进行了检查，以捕获一些无效的内存访问。由您决定是否在那里中断调试器，并显示您尝试使用的无效指针。一旦你知道了哪一个指针，调试器就有各种各样的好东西来找出指针无效的原因。你的调用堆栈图片不是调用堆栈。这是一个断言，没有说明哪个函数触发了它，哪个函数调用了那个函数，哪个函数调用了那个函数，等等，直到你最终到达你的代码。我建议您参考VS调试器教程。它可能是最用户友好的调试器界面，任何努力都将立即获得巨大的回报。类成员是elementos
，带有一个o。它给出了相同的错误，因为代码有“elements”和“elementos”所以这些是不同的变量，我将在其他windows pc上尝试，如果我有错误，我会认为这是因为windows或Visual studio需要特定的方法或something@YunbinLiu如果代码在Visual Studio中不起作用，然后它在Linux中确实不能正常工作——相反，您依赖于未定义的行为。我更新了消息中错误的调用堆栈“我如何删除“TList”对象？”？你没有。如果不使用“新建”，则不会删除。尽管这样说，你有一个漏洞，因为GetReverseList（）返回一个指针。我把整个代码放在“delete listReverse”中，问题出在“delete listReverse”中；GetReverseList中有一个新的，所以我需要执行delete操作，所以解决方案是执行main（）中的操作在问题中的代码中，而不是在我们看不到的PC上的代码中，您当前正在做什么。意思是listReverse需要是指向TList的指针。
#include <vector>
#include <string.h>
#include <algorithm>
#include <stdio.h>
#include <tchar.h>

class TList {
private:
     std::vector<const char*> elementos;
     int position;
     TList(std::vector<const char*> elementos);
public:
    TList(const char** e, int s);
    TList(const TList & list);
    TList GetReverseList(TList lstSrc);
    TList *GetReverseList();
    int Size();
    const char *Next();
};

TList::TList(const char** e, int s) {
    std::vector<const char*> res (&e[0], &e[s]);
    elementos = res;
    position = 0;
}

TList::TList(std::vector<const char *> elements) {
    std::vector<const char*> res = std::vector<const char*>();
    int size = elements.size();
    for (int i = 0; i < size; i++) {
        res.push_back(elements.at(i));
    }
    elementos = res;
    position = 0;
}

TList::TList(const TList & list) {
    std::vector<const char*> el = std::vector<const char*>();
    int size = list.elementos.size();
    for (int i = 0; i < size; i++) {
        el.push_back(list.elementos[i]);
    }
    elementos = el;
    position = 0;
}

//Create a new TList * with the reverse list of elements
TList *TList::GetReverseList() {
    TList *res = new TList(elementos);
    std::reverse(res->elementos.begin(), res->elementos.end());
    return res;
}

//Create a new TList with the reverse list of elements
TList TList::GetReverseList(TList lstSrc) {
    TList *res = new TList(lstSrc);
    std::reverse(res->elementos.begin(), res->elementos.end());
    return *res;
}

int TList::Size() {
    return elementos.size();
}

//Use the position to get the next char *
const char * TList::Next() {
    const char * res;
    if (elementos.empty()) {
        res = NULL;
    }
    else {
        int pos = position;
        int size = elementos.size();
        res = pos == size ? elementos.at(position - 1) : elementos.at(position);
        if (pos < size) {
            position++;
        }
    }
    return res;
}

int main()
{
    int size = 2;
    const char *arr[2] = {"Hola", "AAAA"};
    TList *list = new TList(arr, size);
    TList listReverse = list->GetReverseList(*list);
    TList *listReverseOptimized = list->GetReverseList();
    delete list;
    delete listReverse;
    delete listReverseOptimized;
    return 0;
}