在C中,typedef不会授予您任何其他类型安全性.您可以在任何可以使用旧类型的地方使用新类型.有时这就是我想要的,有时却不是.有时我希望编译器在我滥用新类型时警告我.
为了实现这一点,我有时做这样的事情:
typedef struct {
int value;
} NewType;
NewType doSomethingNT(NewType a, NewType b) {
return a.value + b.value;
}
相比:
int doSomethingI(int a, int b) {
return a + b;
}
(这只是一个例子.让我们假设在两种情况下都有一个函数调用开销,否则我要求函数在两种情况下都内联.但是我们不要将doSomethingNT与bare +运算符进行比较,显然后者更快因为它没有函数调用开销)
我想我问,是否有任何开销在"装箱"原始类型的单元素结构,但使用该结构作为值类型.(即我不是在调用malloc并使用指针,就像拳击在Java中一样.)
#include <iostream>
using namespace std;
struct node1{
char b[3];
int c[0];
};
struct node2{
int c[0];
};
struct node3{
char b[3];
};
int main() {
cout << sizeof(node1) << endl; // prints 4
cout << sizeof(node2) << endl; // prints 0
cout << sizeof(node3) << endl; // prints 3
}
我的问题是为什么编译器为node2中的int c [0]分配0个字节,但为node1的一部分分配1个字节.我假设这个1字节是sizeof(node1)返回4的原因,因为没有它(如在node3中)它的大小是3或者是由于填充？
还试图理解不应该node2有足够的空间来容纳一个指向数组的指针(作为灵活的数组/结构黑客的一部分,它将在代码中进一步分配？
有没有办法看看在构建期间如何打包C结构？我已经阅读了几篇关于如何打包结构的类似帖子:
但我想知道是否有某种构建时生成的文件,它向我展示了如何打包结构？我尝试检查链接器生成的映射文件,但它没有此信息.
PS:我试图让一些微控制器通过UART相互通信,因为一个是16位而其他的是32位,每次更新这些结构时我都会遇到一些错误.
struct Something
{
int a;
int b;
Something(char* buffer)
{
memcpy(this, buffer, sizeof(Something));
};
};
这合法吗？安全？对我来说它看起来很好,但我不确定C++标准是否以某种方式禁止它.
当我输入以下代码时，得到的结果是32个字节。它应该是28个字节。为什么我得到那个结果？
//size of union variable
union U {
int x[7];
double y[3];
}z;
int main(){
printf("%d",sizeof(z));
return 0;
}
我很想知道为什么具有相同数据类型的位字段比使用混合数据类型更小.
struct xyz
{
int x : 1;
int y : 1;
int z : 1;
};
struct abc
{
char x : 1;
int y : 1;
bool z : 1;
};
sizeof(xyz)= 4 sizeof(abc)= 12.
我正在使用VS 2005,64位x86机器.
一台机器/编译器级别的答案会很棒.
我试图理解位域的概念.但我无法找到CASE III中以下结构的大小为8字节的原因.
struct B
{
unsigned char c; // +8 bits
} b;
的sizeof(B); //输出:1(因为unsigned char在我的系统上占用1个字节)
struct B
{
unsigned b: 1;
} b;
sizeof(b); // Output: 4 (because unsigned takes 4 bytes on my system)
struct B
{
unsigned char c; // +8 bits
unsigned b: 1; // +1 bit
} b;
sizeof(b); // Output: 8
我不明白为什么案例III的输出为8.我期待1(char)+ 4(无符号)= 5.
我试图理解C中的结构的内存分配,但我坚持下去.
struct Person {
char *name;
int age;
int height;
int weight;
};
struct Person *Person_create(char *name, int age, int height, int weight)
{
struct Person *who = malloc(sizeof(struct Person));
assert(who != NULL);
who->age = age;
who->height = height;
who->weight = weight;
who->name = strdup(name);
return who;
}
int main(int argc, char *argv[])
{
struct Person *joe = Person_create("ABC", 10, 170, 60);
printf("Size of joe: %d\n", sizeof(*joe));
printf("1. Address of joe \t= %x\n", joe);
printf("2. Address of Age \t= %x\n", …为了了解std::vector<int>我写的内存消耗：
std::cout << sizeof(std::vector<int>) << std::endl;
这产生32. 我试图理解这个价值从何而来。有些人查看了std::vector存储指针的源代码_MyFirst，_MyLast并_MyEnd解释了 24 字节的内存消耗（在我的 64 位系统上）。
最后一个字节怎么样8？据我了解，存储的分配器不使用任何内存。另外，这可能是实现定义的（是吗？），所以这可能有帮助：我正在使用 MSVC 2017.5。我不保证通过查看代码找到所有成员；该代码对我来说看起来非常混乱。
一切似乎都很好地对齐，但答案可能如下？：为什么结构体的 sizeof 不等于每个成员的 sizeof 之和？。但我用一个简单的测试它struct Test { int *a, *b, *c; };满足sizeof(Test) == 24.
一些背景
在我的程序中，我将有很多向量，但似乎其中大部分都是空的。这意味着关键的内存消耗来自空状态，即堆分配的内存不是那么重要。
一个简单的“仅用于此用例”向量很快就实现了，所以我想知道我是否遗漏了任何东西，无论如何我都需要 32 字节的内存，即使使用我自己的实现（注意：我很可能不会实现我自己的，这只是好奇心）。
更新
我用以下结构再次测试了它：
struct Test
{
int *a, *b, *c;
std::allocator<int> alloc;
};
现在给了sizeof(Test) == 32。看起来，即使std::allocator没有消耗内存的成员（我认为），它的存在也会将Test …
我有这段代码在AMD64兼容CPU上运行Ubuntu 14.04时会出现段错误:
#include <inttypes.h>
#include <stdlib.h>
#include <sys/mman.h>
int main()
{
uint32_t sum = 0;
uint8_t *buffer = mmap(NULL, 1<<18, PROT_READ,
MAP_PRIVATE|MAP_ANONYMOUS, -1, 0);
uint16_t *p = (buffer + 1);
int i;
for (i=0;i<14;++i) {
//printf("%d\n", i);
sum += p[i];
}
return sum;
}
如果使用分配内存,则仅此段错误mmap.如果我使用malloc,堆栈上的缓冲区,或全局变量,它不会段错误.
如果我将循环的迭代次数减少到少于14的次数,则不再是段错误.如果我从循环内打印数组索引,它也不再是段错误.
为什么未对齐的内存访问能够访问未对齐地址的CPU上的段错误,为什么只有在这种特定情况下呢？