C++ 检测我指的是什么

有没有办法检测p和d指向的对象是否属于不同的类型？（p指向整数，d指向整数数组）：

…p和d指向的对象是不同类型的？（p指向整数，d指向整数数组）：

首先，这不是真的正确。是，

d

指向数组的开头，但是 它们都指向完全相同的东西；一个

int

。是否可以安全地对指针执行算术运算，然后取消引用它是另一个问题

当您取消引用它们时，机器只会返回一个大小合适的内存块，并将其解释为int

C++并不完全是元编程的goto语言，如果你处理的是指针，它真的很重要吗？我从来没有觉得有必要这么做。你知道你有一个指针，你（应该）知道它是指向你声明的一个

int

还是一堆

int

s，那么你到底想解决什么问题呢

…p和d指向的对象是不同类型的？（p指向整数，d指向整数数组）：

首先，这不是真的正确。是，

d

指向数组的开头，但是 它们都指向完全相同的东西；一个

int

。是否可以安全地对指针执行算术运算，然后取消引用它是另一个问题

当您取消引用它们时，机器只会返回一个大小合适的内存块，并将其解释为int

C++并不完全是元编程的goto语言，如果你处理的是指针，它真的很重要吗？我从来没有觉得有必要这么做。你知道你有一个指针，你（应该）知道它是否指向你声明的一个

int

或一堆

int

，那么你到底想解决什么问题呢？

我想说不。 p和d都是指向int的指针，d是指向数组头部的指针，头部是int

int数组不是d的类型-它是指向int的指针，我想说不是。

#include <iostream>
#include <typeinfo>

using namespace std;

int main()
{
    int* p = new int();
    int* d = new int[20];
    float* f = new float();

    if (typeid(p) == typeid(d))
            cout << "equal" << endl;
    else
            cout << "not equal" << endl;

    if (typeid(p) == typeid(f))
            cout << "equal" << endl;
    else
            cout << "not equal" << endl;

}

p和d都是指向int的指针，d是指向数组头部的指针，头部是int

int数组不是d类型-它是指向int的指针

#include <iostream>
#include <typeinfo>

using namespace std;

int main()
{
    int* p = new int();
    int* d = new int[20];
    float* f = new float();

    if (typeid(p) == typeid(d))
            cout << "equal" << endl;
    else
            cout << "not equal" << endl;

    if (typeid(p) == typeid(f))
            cout << "equal" << endl;
    else
            cout << "not equal" << endl;

}

有没有办法检测p和d指向的对象是否属于不同的类型

你的假设是错误的。p和q都指向同一类型，一个int

有没有办法检测p和d指向的对象是否属于不同的类型

---

你的假设是错误的。p和q都指向同一类型，一个int。

如果你实现你自己的

new

和

new[]

你可以，但是这里的龙会把你活活吃掉：

void * operator new(size_t size)
{
    size_t * allocation = (size_t *)malloc(size+sizeof(size_t));
    *allocation = size;
    return allocation + 1;
}

void * operator new[](size_t size)
{
    size_t * allocation = (size_t *)malloc(size+sizeof(size_t));
    *allocation = size;
    return allocation + 1;
}

template<typename T> size_t allocationCount(T*memory)
{
    size_t * allocation = reinterpret_cast<size_t*>(memory) - 1;
    return *allocation / sizeof(T);
}

int main()
{
    int * fred = new int;
    int * nurk = new int[30];
    cout << allocationCount(fred) << endl;
    cout << allocationCount(nurk) << endl;
}

---

如果你实现自己的

new

和

new[]

你可以，但是这里的龙会活活吃掉你：

void * operator new(size_t size)
{
    size_t * allocation = (size_t *)malloc(size+sizeof(size_t));
    *allocation = size;
    return allocation + 1;
}

void * operator new[](size_t size)
{
    size_t * allocation = (size_t *)malloc(size+sizeof(size_t));
    *allocation = size;
    return allocation + 1;
}

template<typename T> size_t allocationCount(T*memory)
{
    size_t * allocation = reinterpret_cast<size_t*>(memory) - 1;
    return *allocation / sizeof(T);
}

int main()
{
    int * fred = new int;
    int * nurk = new int[30];
    cout << allocationCount(fred) << endl;
    cout << allocationCount(nurk) << endl;
}

---

为什么要检测它？这是不可能做到的。是的，通过声明后的方括号（好吧，这是一个愚蠢的评论），这并不完全是你要问的，但它是相关的。出于优化目的，编译器可能会跟踪类似的详细类型信息。为什么要检测它？这是不可能做到的。是的，通过声明后的方括号（好吧，这是一个愚蠢的评论），这并不完全是你要问的，但它是相关的。出于优化目的，编译器可能会跟踪类似的详细类型信息-1它们都是指向int的指针。。。即使是

typeid（*p）

（与

q

相同）也将是

int

。是的，您可以，但您的示例指向相同的类型。-所以答案是。。。不，你不能。-1他们都是指向int。。。即使是

typeid（*p）

（与

q

相同）也将是

int

。是的，您可以，但您的示例指向相同的类型。-所以答案是。。。不，你不能。啊！真正地这是一种不可能充分和无法使用的方法。你考虑过<代码>新INT（1）< /代码>吗？一旦你处理好了这个问题，你就可以继续处理其他几十个问题了，你将要面对如何让它发挥作用。啊！真正地这是一种不可能充分和无法使用的方法。你考虑过<代码>新INT（1）< /代码>吗？一旦你解决了这个问题，你就可以继续处理其他几十个你将面临的问题，试图让它正常工作。#Ed“问题”是我希望能够写delete_up（p），并根据p的“类型”调用delete p或delete[]p@smallB：你只需要知道你一开始分配了什么。为什么这么难？与其问一个毫无意义的解决方案，不如告诉我们你实际上想解决什么问题。我从来不需要在运行时确定调用哪个版本的

delete

。#我没有说我需要在运行时检测它。我只想有“智能”删除，这将节省我检查我正在删除什么，数组与否。就这样。现在说得通了吗？@smallB：不太通。我是说，我明白你的意思，但问题是这是不可能的。如果一个版本足够的话，语言设计者就不会创建两个版本。问题是我希望能够编写delete（p），并根据p的“类型”调用delete p或delete[]p@smallB：你只需要知道你一开始分配了什么。为什么这么难？与其问一个毫无意义的解决方案，不如告诉我们你实际上想解决什么问题。我从来不需要在运行时确定调用哪个版本的

delete

。#我没有说我需要在运行时检测它。我只想有“智能”删除，这将节省我检查我正在删除什么，数组与否。就这样。现在说得通了吗？@smallB：不太通。我是说，我明白你的意思，但问题是

1
30