相关疑难解决方法(0)

为什么sizeof操作员返回的结构尺寸大于结构成员的总尺寸？

我想知道是否有人可以向我解释#pragma pack预处理器语句的作用,更重要的是,为什么人们会想要使用它.

我查看了MSDN页面,它提供了一些见解,但我希望能从有经验的人那里听到更多.我以前在代码中看过它,虽然我似乎无法找到它的位置.

[不是结构填充和包装的重复。这个问题是关于填充的方式和时间。这是关于如何处理它的信息。]

我刚刚意识到C ++中的对齐会浪费多少内存。考虑以下简单示例：

struct X
{
    int a;
    double b;
    int c;
};

int main()
{
    cout << "sizeof(int) = "                      << sizeof(int)                      << '\n';
    cout << "sizeof(double) = "                   << sizeof(double)                   << '\n';
    cout << "2 * sizeof(int) + sizeof(double) = " << 2 * sizeof(int) + sizeof(double) << '\n';
    cout << "but sizeof(X) = "                    << sizeof(X)                        << '\n';
}

使用g ++时，程序将提供以下输出：

sizeof(int) = 4
sizeof(double) = 8
2 * sizeof(int) + sizeof(double) = 16
but …

我知道在C#中你可以使用String.Format方法.但是你如何在C++中做到这一点？是否有一个函数允许我将一个字节转换为十六进制？只需将8字节长的数据转换为Hex,我该怎么做？

在C中定义结构时,有关于填充的注意事项,如果结构大小是一个问题,则通常重新排列值以避免填充.(参见:结构填料和包装)

我的问题是:

相同(或类似)的规则是否适用于函数参数？...在安排参数以避免参数填充字节方面有什么好处吗？

• 假设这不是inline(它不重要),或者static编译器可以重新排列参数的函数.

• 接受现实世界可衡量的改善可能很小.

...实际上,如果函数调用开销是一个问题,可能值得内联函数.尽管如此,内联并不总是一个选项(例如库或函数指针).

为什么尺寸struct A不等于struct B？

而我需要做的是,它们的尺寸相同吗？

using System;

namespace ConsoleApplication1
{
    class Program
    {
        struct A
        {
            char a;
            char c;
            int b;
        }

        struct B
        {
            char a;
            int b;
            char c;

        }


        static void Main(string[] args)
        {
            unsafe
            {
                Console.WriteLine(sizeof(A));
                Console.WriteLine(sizeof(B));
            }
            Console.ReadLine();
        }
    }
}

输出是:

8
12

我正在编写一个与VHDL中定义的许多寄存器接口的应用程序.寄存器为32位宽,并分配成组.我为该组的每个成员提供了组的基址和32位偏移量.以下是一个组的示例,组内的寄存器和寄存器的结构.

目前,使用以下位字段结构处理I/O,

typedef struct
{
   uint32_t   data0 : 12;
   uint32_t   data1 : 1;
   ...
}volatile data_port;

并使用指向地址的指针修改字段,

data_port *const p_data = (data_port *)0xc006380;

虽然这可能在这个平台上有效,但是对于当前的编译器,我担心可移植性.我想知道在强制使用这些非常规数据类型时是否有更好的方法来处理硬件接口？

我能想到的另一种选择是在硬件和寄存器结构之间创建另一层,使用易失性无符号int指针,并在应用层中使用位域结构.问题是,数据仍然必须从位字段(可能在另一个平台上以不同方式对齐)复制到int,这可能是另一个主题.

编辑:
我认为我真正想要的是一种消除位域使用的方法.将具有位字段成员的结构映射到硬件实际上似乎是一种糟糕的方法.所以,为了消除这一点,我将使用以下之一作为指向易失性存储器地址的指针,

#define PeripheralBase ((uint32_t volatile *)BASE)

要么

uint32_t volatile *const peripheral_base  = (uint32_t *) BASE;

希望,一旦我达到这一点,一切都将在32位内完全一致.我想要做的一个方法是创建相同的data_port结构,但是删除位打包,然后右边一个函数专门为每个寄存器将位移位到unsigned int,然后可以使用它传递给寄存器易失性指针.

就像是,

static inline uint32_t struct_to_uint(data_port *data)
{
   return data->data0
        + ((uint32_t)data->data1 << 12)
        + ((uint32_t)data->data2 << 13)
        + .....;
}

我不确定语法是否正确,但我们的想法是将值转移而不必担心编译器或平台.这是否因为？这种方法是否存在可移植性问题？

我正在尝试使用 ifstream 从文件中读取二进制数据。

具体来说，我试图用从文件中读取的数据填充这个“标题”结构：

struct Header {
    char id[16];
    int length;
    int count;
};

1. 现在，如果我以这种方式读取文件，结果正是我想要的：

   input.read((char*)&hdr, sizeof(hdr));
   

   Run Code Online (Sandbox Code Playgroud)

2. 但是，如果我改为手动读取结构的每个变量，结果是乱码：

   input.read((char*)&hdr.id,     sizeof(hdr.id));
   input.read((char*)&hdr.length, sizeof(hdr.length));
   input.read((char*)&hdr.count,  sizeof(hdr.count));
   

   Run Code Online (Sandbox Code Playgroud)

我的问题是，这里发生了什么使这两种方法返回不同的结果？

前言: 我对结构对齐的研究.看着这个问题,这一个也是这个 - 但仍然没有找到我的答案.

我的实际问题:

这是我创建的代码片段,以澄清我的问题:

#include "stdafx.h"
#include <stdio.h>

struct IntAndCharStruct
{
    int a;
    char b;
};

struct IntAndDoubleStruct
{
    int a;
    double d;
};

struct IntFloatAndDoubleStruct
{
    int a;
    float c;
    double d;
};

int main()
{
    printf("Int: %d\n", sizeof(int));
    printf("Float: %d\n", sizeof(float));
    printf("Char: %d\n", sizeof(char));
    printf("Double: %d\n", sizeof(double));
    printf("IntAndCharStruct: %d\n", sizeof(IntAndCharStruct));
    printf("IntAndDoubleStruct: %d\n", sizeof(IntAndDoubleStruct));
    printf("IntFloatAndDoubleStruct: %d\n", sizeof(IntFloatAndDoubleStruct));
    getchar();
}

它的输出是:

Int: 4
Float: 4
Char: 1
Double: 8
IntAndCharStruct: 8
IntAndDoubleStruct: 16 …

void main()
{
  struct bitfield
  {
    signed int a :3;
    unsigned int b :13;
    unsigned int c :1;
  };

  struct bitfield bit1 = { 2, 14, 1 };
  clrscr();
  printf("%d", sizeof(bit1));
  getch();
}

为什么大小为4字节？这些元素究竟是如何存储在内存中的？