最近，我看到这样的说法：
所有指针具有相同的大小是很常见的，但从技术上讲，指针类型具有不同的大小是可能的。
但后来我发现了这样的内容：
虽然指针的大小都是相同的，因为它们只存储内存地址，但我们必须知道它们指向什么类型的东西。
现在，我不确定以上哪种说法是正确的。第二个引用的语句看起来像是来自佛罗里达州立大学计算机科学的 C++ 笔记。
这就是为什么在我看来所有指针都应该具有相同的大小：
1）假设我们有：
int i = 0;
void* ptr = &i;
现在，假设 C++ 标准允许指针具有不同的大小。进一步假设在某些任意机器/编译器上（因为标准允许），a 的void*大小为 2 字节，而 a 的int*大小为 4 字节。
现在，我认为这里有一个问题，即右侧有一个int*大小为 4 字节的 ，而左侧有一个void*大小为 2 字节的 。int*因此，当从到发生隐式转换时，void*将会丢失一些信息。
2)所有指针都保存地址。由于对于给定的机器，所有地址都具有相同的大小，因此所有指针也应该具有相同的大小是非常自然（合乎逻辑的）。
因此，我认为第二句话是正确的。
我的第一个问题是 C++ 标准对此有何规定？
我的第二个问题是，如果 C++ 标准确实允许指针具有不同的大小，那么有理由吗？我的意思是允许指针具有不同的大小对我来说似乎有点不自然（考虑到我上面解释的两点）。所以，我很确定标准委员会一定已经考虑到了这一点（指针可以有不同的大小），并且已经有理由允许指针有不同的大小。请注意，只有当标准确实允许指针具有不同的大小时，我才会问这个（第二个问题）。
c++ pointers void-pointers language-lawyer pointer-conversion
是char*,int*,long*甚至是long long*同样大小的(在给定的平台)？
我有一个看起来像这样的模板
template <typename T> class Foo
{
public:
Foo(const T& t) : _t(t) {}
private:
const T _t;
};
在参数类型像 bool 或 char 这样微不足道的情况下，是否有一种精明的模板元编程方法可以避免使用 const 引用？喜欢：
Foo(stl::smarter_argument<T>::type t) : _t(t) {}
我对 C 指针如何实际引用变量的内存地址感到困惑。我可能在这里遗漏了一些东西，但是，例如，如果 int 是 32 位（如 C 中的），那么它将存储在 4 个字节中。
如果我没有记错的话，那么每个内存地址的大小往往是一个字节，因为这些通常是可寻址内存的最小单位。那么如果一个int占用4个字节，那么它不是就有4个内存地址吗？（因为它存储在 4 个 8 位内存地址上）。
如果是这样的话，那么为什么一个指针只保存一个内存地址呢？（或者更确切地说，如果它可以容纳更多内容，则在打印时仅显示一个？）。这只是存储 int 的第一个地址吗？（假设它们是连续存储的）。
我试图在网上寻找答案，但这只会导致进一步的混乱。
海湾合作委员会给了我以下警告:
note: expected 'const void **' but argument is of type 'const struct auth **
有没有可能导致问题的情况？
更大的片段是
struct auth *current;
gl_list_iterator_next(&it, ¤t, NULL);
函数只存储在current一些void *指针中.
到目前为止我读过的所有书籍中，他们都说 C++ 模板为我们使用的每种类型生成一个代码实例。
另一方面，书上说在 C# 中代码是重用的。
因此，我在许多书籍中进行了搜索，并在一本很旧的书中找到了以下 C# 示例。
1) 值类型
List<int> intList1 = new List<int>();
List<int> intList2 = new List<int>();
List<bool> boolList = new List<bool>();
在这种情况下（值类型），编译器为 intList1 和 intList2（相同类型）生成一个代码实例，并为 boolList 生成一个代码实例。
2) 参考类型
List<Dog> dogList1 = new List<Dog>();
List<Dog> dogList2 = new List<Dog>();
List<Cat> catList = new List<Cat>();
在这种情况下（引用类型），编译器只为dogList1、dogList1和catList生成一个代码实例，因为只要它可以表示指向对象的指针，所有引用类型都可以共享一个实现。
这对我（作为 C++ 开发人员）来说非常清楚，但我对有关 C++ 模板的同样的事情感到好奇。
早在 C# 创建之前，C++ 也有值类型和引用类型。
因此，让我们用 C++ 重写 avove 示例
1) 值类型
vector<int> intList1;
vector<int> intList2;
vector<bool> boolList;
在这种情况下，我毫不怀疑 intList1 和 intList2 共享相同的代码，并且 boolList 需要另一个实现
2) …
我遇到了这种在 C++ 中读取 BMP 文件的语法
#include <fstream>
int main() {
std::ifstream in('filename.bmp', std::ifstream::binary);
in.seekg(0, in.end);
size = in.tellg();
in.seekg(0);
unsigned char * data = new unsigned char[size];
in.read((unsigned char *)data, size);
int width = *(int*)&data[18];
// omitted remainder for minimal example
}
我不明白线路是什么
int width = *(int*)&data[18];
实际上是在做。为什么从unsigned char *to int, int width = (int)data[18];,的简单转换不起作用？
当然int,并long不能保证是同一类型,而是一个平台,如Windows在32位模式下,他们恰好是同样大小编译时,被编译器允许把它们视为同一类型？
我不确定如何明确地测试编译器是否将两种类型视为相同,但我尝试使用启发式测试,int *a; long *b = a;并且Microsoft编译器接受此而没有投诉,而GCC发出警告.是编译器行为不正确还是依赖于实现,无论它们是两个不同的类型还是仅一个？
我需要对C++内存分配做一些澄清,我只是举个例子
假设我已经创建了一个类A,它包含两个容器:一个hash_map和一个std :: vector,如下所示:
class Example{
// methods to add stuff to containers
//...
std::hash_map<std::string,int> map;
std::vector<std::string> vec;
}
如果我然后使用new运算符在堆上创建示例对象:
Example* ex = new Example();
并为每个容器添加一千个条目,我添加的条目也将位于堆上吗？如果是,那么如果我这样做会有什么不同:
class Example{
// methods to add stuff to containers
//...
std::hash_map<std::string,int>* map;
std::vector<std::string>* vec;
}
然后 Example* ex = new Example();
我正在尝试将 argv 中传递的一些参数复制到字符串数组中。这是我的程序。
#include <string.h>
#include <stdlib.h>
#include <unistd.h>
int main (int argc, char * argv[]) {
char **args = malloc(argc * sizeof(char *));
for (int i = 0; i < argc - 1; ++i) {
strcpy(*(args+i), argv[i+1]);
}
}
我在 for 循环中遇到分段错误。为什么会这样？
我的问题：
intfloatcharstr这些 var 类型都有为其分配的标准化字节分配。但我从来没有了解过这一点的指针：
这些“地址”存储变量，其内容看起来只是一系列字母数字字符。
C++代码：
int *ptr1;
char *ptr2;
void *ptr3;
那么上面列出的指针的标准内存分配是什么呢？一般来说呢？
我想在内存中的结构后面添加一个字符串。如何检查我是否动态分配了正确数量的字节？
例子：
const wchar_t* add_str = L"test string";
struct test_{
wchar_t* name;
size_t namelen;
} test;
void* ptest_void = malloc(sizeof(test) + wcslen(add_str)*sizeof(wchar_t));
// i cant dereference void*, hence, cant check sizeof(*ptest_void)
// then i try to get sizeof of a ptr which was cast to (test_*):
test_* ptest = (test_*)ptest_void;
size_t ptest_sz = sizeof(*ptest);
// ptest_sz has the size of _test struct, but without size of add_str...
free(ptest_void);
这可能是一个菜鸟问题..但这真让我感到困惑..
下面是一些示例代码
void main() {
int a = 300;
char *ptr = &a;
int *intptr = &a;
printf("%d\n %d\n", *ptr, *intptr);
}
产量:
44
300
根据我的理解,为什么解除引用*ptr打印44是由于char指针是一个字节的事实,所以它只从int的地址读取8位...
但是这个问题:指针的大小是多少？状态Regardless of what data type they are pointing to, they have fixed size
我错过了一些东西.为什么解引用char指针打印44,如果指针大小相同？