Question

例如：

int *start;
start = (int*)malloc(40);

如果我想迭代所有40个字节，我该怎么做？我尝试过这样的事情：

while(start != NULL){
     start++;
}

但是迭代了大量的值，远远大于40.因此，如何确保迭代所有40个字节。

感谢所有帮助。

Answer 1

这里有两个问题。

单个ptr ++跳过与其指向的元素类型一样多的字节。

这里的类型是 int ，所以它每次跳过 4个字节（假设32位机器，因为整数是4个字节（32位））。 / p>

如果要迭代所有40个字节（一次一个字节），请使用char数据类型进行迭代（或者将int *类型转换为char *然后递增）

另一个问题是你的循环终止。

这里没有人在这里放置一个NULL，所以你的循环会继续运行（并且指针向前推进），直到它遇到可能是null或者超出你分配的内存区域并崩溃。 行为未定义。

如果你分配了40个字节，你必须自己终止40个字节。

<强>更新

基于评论和对原始问题的投票，值得一提的是，在C中输入malloc的结果类型并不是一个好主意。主要原因是它可能会篡改失败的分配< / em>的。但它是C ++的一项要求。详细信息可以在SO上的完全相同的问题中找到。搜索“malloc的返回值”

Answer 2

首先，您应该正确分配int：

int* start = malloc( sizeof( int )*40 ) ;

然后你可以使用数组下标：

for( size_t i = 0 ; i < 40 ; i++ )
{
    start[i] = 0 ;
}

或指向已分配内存末尾的指针：

int* end = start+40 ;
int* iter = start ;

while( iter < end )
{
    *iter= 0 ;
    iter++ ;
}

Answer 3

数组表示连续的内存块。由于数组的名称基本上是指向第一个元素的指针，因此您可以使用数组表示法来访问块的其余部分。但是请记住，C对数组的边界没有错误检查，所以如果你走出内存块的末尾，你可以做各种你不想要的事情，而且最终可能会结束。某种内存故障或分段错误。由于你的int可以是可变大小，我会改用这段代码：

int *start;
int i;

start = malloc(40 * sizeof(int));

for (i = 0; i < 40; i++)
  {
    start[i] = 0;
  }

这样的东西会很好用。你正在这样做的方式，至少从你发布的代码中，没有办法停止循环，因为一旦它超过内存块，它将继续运行，直到它遇到NULL或你得到内存错误。换句话说，循环只有在遇到null时才会退出。该null可能在您分配的内存块内，或者可能超出了块。

编辑：有一点我注意到我的代码。它将为40个整数分配空间，可以是4个字节，8个字节或其他东西，具体取决于您正在处理的机器的体系结构。如果你真的只想要40个字节的整数，那么就这样做：

int *start;
int i;
int size;

size = 40/sizeof(int);
start = malloc(size);
for (i = 0; i < size; i++)
  {
    start[i] = 0;
  }

或者，如果需要，可以使用char数据类型或unsigned char。我注意到的另一件事。 malloc函数返回一个与所有指针兼容的void指针类型，因此不需要在malloc上进行类型转换。

Answer 4

C中的井阵列没有限制，有几个选项，最常见的是：

        //     Gets the days component of the time interval represented by the current System.TimeSpan
        //     structure.
        //
        // Returns:
        //     The day component of this instance. The return value can be positive or negative.
        public int Days { get; }


        // Summary:
        //     Gets the hours component of the time interval represented by the current
        //     System.TimeSpan structure.
        //
        // Returns:
        //     The hour component of the current System.TimeSpan structure. The return value
        //     ranges from -23 through 23.
        public int Hours { get; }


        // Summary:
        //     Gets the milliseconds component of the time interval represented by the current
        //     System.TimeSpan structure.
        //
        // Returns:
        //     The millisecond component of the current System.TimeSpan structure. The return
        //     value ranges from -999 through 999.
        public int Milliseconds { get; }


        // Summary:
        //     Gets the minutes component of the time interval represented by the current
        //     System.TimeSpan structure.
        //
        // Returns:
        //     The minute component of the current System.TimeSpan structure. The return
        //     value ranges from -59 through 59.
        public int Minutes { get; }


        // Summary:
        //     Gets the seconds component of the time interval represented by the current
        //     System.TimeSpan structure.
        //
        // Returns:
        //     The second component of the current System.TimeSpan structure. The return
        //     value ranges from -59 through 59.
        public int Seconds { get; }


        // Summary:
        //     Gets the number of ticks that represent the value of the current System.TimeSpan
        //     structure.
        //
        // Returns:
        //     The number of ticks contained in this instance.
        public long Ticks { get; }


        // Summary:
        //     Gets the value of the current System.TimeSpan structure expressed in whole
        //     and fractional days.
        //
        // Returns:
        //     The total number of days represented by this instance.
        public double TotalDays { get; }


        // Summary:
        //     Gets the value of the current System.TimeSpan structure expressed in whole
        //     and fractional hours.
        //
        // Returns:
        //     The total number of hours represented by this instance.
        public double TotalHours { get; }


        // Summary:
        //     Gets the value of the current System.TimeSpan structure expressed in whole
        //     and fractional milliseconds.
        //
        // Returns:
        //     The total number of milliseconds represented by this instance.
        public double TotalMilliseconds { get; }


        // Summary:
        //     Gets the value of the current System.TimeSpan structure expressed in whole
        //     and fractional minutes.
        //
        // Returns:
        //     The total number of minutes represented by this instance.
        public double TotalMinutes { get; }


        // Summary:
        //     Gets the value of the current System.TimeSpan structure expressed in whole
        //     and fractional seconds.
        //
        // Returns:
        //     The total number of seconds represented by this instance.
        public double TotalSeconds { get; }

另一种选择：

int *start;
int cnt = 0;
start = (int*)malloc(sizeof(int)*40);;

while(cnt<40)
{
    start++;
    cnt++;
}

最后一个最接近你的意思：

int *start;
int *ref;
start = ref = (int*)malloc(sizeof(int)*40);

while(start != ref+40)
    start++;

我建议阅读更多有关C中指针如何工作的内容。你似乎没有很好地掌握它。另外，请记住C取下训练轮。数组不以标准方式绑定或终止，并且在遍历数组后指针（内存中的地址）永远不会为NULL，而指针指向的内容可能是任何内容。

你如何迭代指针？

4 个答案: