C++ C++；——确定泛型变量是否为指针

我有一个类，我称之为myclass，它有一个T类型的列表容器。我还有两个方法可以从列表中删除项。如果T是某种类型的指针，我想检查它是否确实是指针，然后删除它，以便将分配的资源释放回内存。下面是一段代码：

template<typename T>
class myclass{
private:
    std::list<T> * container;
    // other vars
public:

    void erase(const T &item){
        if (!this->find(item))     // find is defined elsewhere
            return false;
        auto temp = container->begin();
        for (int i = 0; i < container->size(); ++i){
            // this is where i would like to check if *temp is a pointer,
            // so that I can assign it to a pointer var, remove it from the list,
            // then delete the pointer,
            //otherwise just simply remove it from the list.
        }
    }

};

我想知道如何确定*temp是否为指针，以便执行以下操作：

T * var = *temp;
container->remove(temp);   // remove or erase, i can't recall at the moment
delete var;

---

但我只想在*temp是指针的情况下这样做，我认为这不是一个明智的想法。您不知道用户是否提供了指向堆栈上分配的数据的指针，或者指向以其他方式管理的数据的指针（例如使用智能指针）

但要回答这个问题，请看

std::is_pointer<T>::value  // in type_traits header

std:：is\u指针：：值//在类型\u头中

---

这是一个C++11特性

我认为这不是一个明智的想法。您不知道用户是否提供了指向堆栈上分配的数据的指针，或者指向以其他方式管理的数据的指针（例如使用智能指针）

但要回答这个问题，请看

std::is_pointer<T>::value  // in type_traits header

std:：is\u指针：：值//在类型\u头中

---

这是一个C++11特性

很抱歉，但是没有：

std:：list:：iterator

（这是

begin（）

将返回的，因此将是

temp

的类型）不能是指针。它必须是一种（至少）重载前后递增和递减以进行链表遍历的类型，因此

++

将执行类似

pos=pos->next的操作

和

-

将转换为类似

pos=pos->prev

如果您想知道
*temp
（与T的类型相同）是否是指针，那就完全不同了。你基本上有两条路线。作为一般规则，我希望为指针提供类的专门化：

template<typename T>
class myclass{
private:
    std::list<T> container;
    // other vars
public:

    void erase(const T &item){
        if (!container->find(item))     // find is defined elsewhere
            return false;
        auto temp = container->begin();
        for (int i = 0; i < container->size(); ++i){
            container.erase(temp);
        }
    }

};

template<class T>
class myclass <T *> {
private:
    std::list<T> container;
    // other vars
public:

    void erase(const T &item){
        if (!container->find(item))     // find is defined elsewhere
            return false;
        auto temp = container->begin();
        for (int i = 0; i < container->size(); ++i){
            delete *temp;
            container.erase(temp);
        }
    }
};

模板
类myclass{
私人：
列表容器；
//其他变量
公众：
无效擦除（常数T和项目）{
如果（！container->find（item））//find在别处定义
返回false；
自动温度=容器->开始（）；
对于（int i=0；isize（）；++i）{
容器。擦除（临时）；
}
}
};
样板
类myclass{
私人：
列表容器；
//其他变量
公众：
无效擦除（常数T和项目）{
如果（！container->find（item））//find在别处定义
返回false；
自动温度=容器->开始（）；
对于（int i=0；isize（）；++i）{
删除*临时；
容器。擦除（临时）；
}
}
};

最大的问题是，最终可能会在基本模板和指针专用化之间复制相当数量的内容。有几种方法可以避免这种情况。一种是使用实现公共行为的基类，然后从该基类派生两个专门化来提供专门化行为。另一种方法是使用一些
enable_if
或SFINAE启用不同版本的
erase
函数，具体取决于所包含的类型是否可以取消引用

另外，您可能不应该使用
std:：list*容器--它可能只是
std:：list容器
（或者，在大多数情况下更好的是，
std:：vector container；
）
抱歉，但是没有：
std:：list:：iterator
（这是
begin（）
将返回的，因此将是
temp
的类型）永远不能是指针。它必须是一种（至少）重载前后递增和递减以进行链表遍历的类型，因此
++
将执行类似
pos=pos->next的操作
和
-
将转换为类似
pos=pos->prev

如果您想知道
*temp
（与T的类型相同）是否是指针，那就完全不同了。你基本上有两条路线。作为一般规则，我更喜欢为指针提供类的专门化：

template<typename T>
class myclass{
private:
    std::list<T> container;
    // other vars
public:

    void erase(const T &item){
        if (!container->find(item))     // find is defined elsewhere
            return false;
        auto temp = container->begin();
        for (int i = 0; i < container->size(); ++i){
            container.erase(temp);
        }
    }

};

template<class T>
class myclass <T *> {
private:
    std::list<T> container;
    // other vars
public:

    void erase(const T &item){
        if (!container->find(item))     // find is defined elsewhere
            return false;
        auto temp = container->begin();
        for (int i = 0; i < container->size(); ++i){
            delete *temp;
            container.erase(temp);
        }
    }
};

模板
类myclass{
私人：
列表容器；
//其他变量
公众：
无效擦除（常数T和项目）{
如果（！container->find（item））//find在别处定义
返回false；
自动温度=容器->开始（）；
对于（int i=0；isize（）；++i）{
容器。擦除（临时）；
}
}
};
样板
类myclass{
私人：
列表容器；
//其他变量
公众：
无效擦除（常数T和项目）{
如果（！container->find（item））//find在别处定义
返回false；
自动温度=容器->开始（）；
对于（int i=0；isize（）；++i）{
删除*临时；
容器。擦除（临时）；
}
}
};

最大的问题是，最终可能会在基本模板和指针专用化之间复制相当数量的内容。有几种方法可以避免这种情况。一种是使用实现公共行为的基类，然后从该基类派生两个专门化来提供专门化行为。另一种方法是使用一些
enable_if
或SFINAE启用不同版本的
erase
函数，具体取决于所包含的类型是否可以取消引用

另外，您可能不应该使用
std:：list*容器--它可能只是
std:：list容器
（或者，在大多数情况下更好的是，
std:：vector容器；
）
1）

2） 您如何知道该指针是否指向动态分配的内存

2） 您如何知道该指针是否指向动态分配的内存？
这不是很烦人吗