armazenar dois curtas em um curto

Question

Eu escrevi recentemente um código que usa o mesmo curto não assinado para armazenar dois valores, um resultado e uma identificação, por exemplo:

unsigned short data = new_id();
// result is either 0 or 1 so store it in the rightmost bit and move the id left
data = (data << 1) + get_result();
// ... later ...
// now we can print results like
printf("%u: %u\n", data & 1, data >> 1);

Seria melhor usar apenas uma estrutura para segurar os dois valores ou é esse tipo de coisa comum / aceitável? O programa já lojas tanta memória que eu pensei que eu ia começar a encontrar maneiras de diminuir a memória que usa-se.

Answer 1

Campos binários (mas só se você realmente precisa ser apertado no espaço - sistemas embarcados ou seja, )?

typedef struct id_result {
    unsigned int id : 15;
    unsigned int result : 1;
} id_result;

Caso contrário, sim, usar um struct com definições mais completas e significativas:

typedef uint16 IDTYPE; /* assuming uint16 exists elsewhere */

typedef struct id_result {
    IDTYPE id;
    bool result;
} id_result;

Answer 2

A menos que a memória é incrivelmente apertado, eu poderia ir a rota struct. É muito claro que a maneira e mais fácil para a próxima pessoa que tem de manter seu código.

Lembro-me do tempo em que o M68000 teve 32 registros de endereços pouco, mas apenas 24 pedaços deles foram realmente utilizados. Programadores fez todos os tipos de "otimizações" para armazenar informações nesses outros 8 bits. Boy foram os rostos vermelhos quando versões posteriores do chip, como o M68030, usou todos os 32 bits.

Answer 3

A menos que não há absolutamente fulcral da memória, eu preferiria ir para abordagem mais simples de ter estrutura com duas variáveis ??diferentes. Ele aumenta a legibilidade e reduz os esforços de manutenção.

Answer 4

Se isto é feito unicamente com a finalidade de reduzir o uso de memória, então eu acredito que você não deve fazê-lo. Você é melhor fora de usar uma estrutura com 2 curtas, o que torna o código muito mais legível. A quantidade de memória que você salvar, fazendo isso muito pequena em comparação com os benefícios que você começa fazendo o código mais sustentável.

Eu sugiro que você primeiro perfil do sistema para descobrir se existem vazamentos de memória ou se alguém está desnecessariamente alocar grandes blocos de memória, etc., e, em seguida, tentar resolver esse problema. Se ainda assim você não consegue encontrar uma solução, em seguida, descobrir qual parte do seu programa ocupa a maior parte da memória e tentar redesenhar seu modelo de alocação de memória.

Answer 5

Para aqueles que desaconselham a conservação de memória com bitfields: como os anos passam e os computadores ficam mais gigabytes, L1 $ (a memória rápida) permanece apenas algumas dezenas de kilobytes. Para a maioria das aplicações de hoje, a maioria do tempo é gasto à espera de memória lento para chegar na L1 $.

Como a memória lenta é o gargalo na maioria das aplicações, a conservação de memória com bitfields pode realmente aumentar significativamente a velocidade de um aplicativo. Isso não era como verdadeiros vinte anos atrás.

Answer 6

Montagem ambos os calções em um único curto si mesmo é, na minha opinião, mais trabalho e mais do que usar um struct propenso a erros. Se estiver usando menos memória é realmente necessário, você pode especificar bitfields com um struct:

struct myStruct {
int data:8;
int result:8;
};

Ele obtém o mesmo resultado de redução de memória, enquanto o aumento da capacidade de manutenção geral do código.

Answer 7

Structs com bitfields são a implementação mais compreensível. Se você não usar essa abordagem, você poderia usar um conjunto de bem documentado macros que embalar e desembalar o par de valores dentro e fora dos valores de 16 bits.

Answer 8

Usando estruturas / objetos não é necessariamente o melhor ou mais clara abordagem.

Suponha que você tenha um conjunto de pontos de dados inteiro simples, mas eles podem ser excluídos ou marcados inválida, se você simplesmente usar o MSB para marcar como 'não usar', então tudo que você precisa para adicionar ao algoritmo é um

if ( item > 0 )
   item += blah

Mas se você tem uma estrutura, em seguida, cada bit de arithmatic agora precisa de um acesso de membro

if ( item.valid() ) 
   item.setValue(item.getValue() + blah);