什么时候在C中分配内存？

Question

我已经得到了代码,它应该在一个字节内移动一点位置.它有效,但我的问题是关于别的什么？

我做错了什么以及我在做的关于example_byte和new_byte的分配方面做得对吗？这个简单的程序太麻烦了吗？我应该没有使用malloc并让编译器更好地完成脏工作？

这里有一些人对评论部分的看法:链接.

#include <stdio.h>
#include <malloc.h>

typedef unsigned __int8 byte;

byte move(byte* our, int indexold, int indexnew)
{
byte oldvalue;
byte newvalue;
byte valuetochange;

valuetochange = 0x01 & ((*our)>>indexold);         // get the value of the bit to be moved
printf("value to change : %d\n", valuetochange);
oldvalue = (*our) & (~(1<<(indexold)));            // del the bit from position indexold
oldvalue = oldvalue & (~(1<<(indexnew)));          // del the bit from position indexnew
printf("deleted: %x\n", oldvalue);

newvalue = oldvalue | (valuetochange<<(indexnew)); // write bit in new position (indexnew)

return newvalue;
}

int main()
{
byte* example_byte;
byte* new_byte;

example_byte = (byte*)malloc(sizeof(byte));
new_byte     = (byte*)malloc(sizeof(byte));

*example_byte = 0xc3;  //  hex 0xc3 = binary 1100 0011
printf("\n");

//*****************************************************
// example 1 (move bit from position 1 to position 5)
// example_byte  1100 0011
//                 ^    ^
//               memorize bit -> valuetochange = 0x01 & ((*our)>>indexold) = 1
//               1100 0011 & 1111 1101 = 1100 0001 delete bit from oldindex (1)
//               1100 0001 & 1101 1111 = 1100 0001 delete bit from newindex (5)
// new_byte      1100 0001 | 0010 0000 = 1110 0001
*new_byte     = move(example_byte, 1, 5);

printf("old byte : %x\n", *example_byte); // 0xc3 (1100 0011)
printf("new byte : %x\n", *new_byte);     // 0xe1 (1110 0001)
printf("\n");

//*****************************************************
// example 2 (move bit from position 6 to position 3)
// example_byte  1100 0011
//                ^   ^
//               memorize bit -> valuetochange = 0x01 & ((*our)>>indexold) = 1
//               1100 0011 & 1011 1111 = 1000 0011 delete bit from oldindex (6)
//               1000 0011 & 1111 0111 = 1000 0011 delete bit ftom newindex (3)
// new_byte      1000 0011 | 0000 1000 = 1000 1011
*new_byte     = move(example_byte, 6, 3);

printf("old byte : %x\n", *example_byte); // 0xc3 (1100 0011)
printf("new byte : %x\n", *new_byte);     // 0x8b (1000 1011)
printf("\n");

//*****************************************************
// example 3 (move bit from position 2 to position 6)
// example_byte  1100 0011
//                ^    ^
//               memorize bit -> valuetochange = 0x01 & ((*our)>>indexold) = 0
//               1100 0011 & 1111 1011 = 1100 0011 delete bit from oldindex (2)
//               1100 0011 & 1011 1111 = 1000 0011 delete bit from oldindex (6)
// new_byte      1000 0011 | 0000 0000 = 1000 0011
*new_byte     = move(example_byte, 2, 6);

printf("old byte : %x\n", *example_byte); // 0xc3 (1100 0011)
printf("new byte : %x\n", *new_byte);     // 0x83 (1000 0011)
printf("\n");

//*****************************************************
// example 4 (move bit from position 2 to position 4)
// example_byte  1100 0011
//                  ^  ^
//               memorize bit -> valuetochange = 0x01 & ((*our)>>indexold) = 0
//               1100 0011 & 1111 1011 = 1100 0011 delete bit from oldindex (2)
//               1100 0011 & 1110 1111 = 1100 0011 delete bit from oldindex (4)
// new_byte      1100 0011 | 0000 0000 = 1100 0011
*new_byte     = move(example_byte, 2, 4);

printf("old byte : %x\n", *example_byte); // 0xc3 (1100 0011)
printf("new byte : %x  ", *new_byte);     // 0xc3 (1100 0011)
printf("\n");

free(new_byte);
free(example_byte);
return 0;
}

Answer 1

当你需要在你声明它的范围之外可见的东西(以及嵌套在它里面的任何范围),或者你需要动态分配内存时,你需要分配内存,比如创建未知大小的数据结构.否则,您应该声明一个局部变量.

Answer 2

如果是单字节,则根本没有理由进行内存分配.你可以声明一个类型的局部变量byte并传递它.

您需要malloc()在需要分配元素数组时使用,并且在编译时不知道元素的数量.当你需要在创建它的函数退出后需要在内存中分配一个大型结构时,你也需要它.如果您正在处理基本类型的变量,那么您应该简单地将其声明为局部变量,这意味着它将在堆栈上自动分配.