c中数组的声明

发布于 2024-11-24 02:04:07 字数 348 浏览 0 评论 0原文

可能的重复：
堆栈变量与堆变量

将数组声明为：

int arr[100];

和

int* arr=(int*)malloc(sizeof(int)*100);

Which 之间有什么区别一个是首选？这涉及到堆内存和堆栈内存之类的东西吗？

原文

Possible Duplicate:
Stack variables vs. Heap variables

What is the difference between declaring an array as:

int arr[100];

and

int* arr=(int*)malloc(sizeof(int)*100);

Which one is preferred? Is there something like heap and stack memory involved in this?

分享到QQ

分享到微博

如果你对这篇内容有疑问，欢迎到本站社区发帖提问参与讨论，获取更多帮助，或者扫码二维码加入 Web 技术交流群。

发布评论

需要登录才能够评论，你可以免费注册一个本站的账号。

清音悠歌 2024-12-01 02:04:07

我建议去书店买一本 Kernighan 和 Ritchie 的《C 编程语言》，也可以选择买一本 Harbison & C 语言。 Steele 的C：参考手册。

第一种情况给你一个 100 个整数的数组，分配在堆栈上。后一种情况为您提供一个指向 int 的指针，其地址是在堆上分配的缓冲区的地址，该缓冲区的大小足以包含 100 个 int。

C 语言从根本上来说是一种与硬件无关的汇编语言。指针和数组之间的区别是故意模糊的，因为数组引用符号是指针算术的语法糖。这：

int foo( int a )
{
  int x[100] = load_X() ;
  int y = x[ a ] ;
  return y ;
}

与此外

int foo( int a )
{
  int *x     = load_X() ;
  int y      = *( x + a ) ;
  // note that the use of sizeof() isn't required.  For the pointer carries around
  // an implicit increment size (the size of the object to which it points). The above
  // is equivalent to
  //
  //   int y = *(int*)((char*)x + (a*sizeof(*x)) ) ;
}

，给定函数 foo() 时，编译器将（或应该）抱怨类型不匹配：

public void foo( int a[] )
{
  ...
}

调用：

int *p = malloc(...) ;

foo(p) ;

应该导致编译器抱怨类型不匹配。

I suggest a trip to the bookstore to pickup a copy of Kernighan and Ritchie's The C Programming Language, and optionally, a copy of Harbison & Steele's C: A Reference Manual.

The first case gives you an array of 100 ints, allocated on the stack. The latter case gives you a pointer to an int, whose address is that of a buffer allocated on the heap, the size of which is large enough to contain 100 ints.

The C language is fundamentally a hardware agnostic assembly language. The distinction between a pointer and an array is intentionally fuzzy, since array reference notation is syntactic sugar for pointer arithmetic. This:

int foo( int a )
{
  int x[100] = load_X() ;
  int y = x[ a ] ;
  return y ;
}

is identical to

int foo( int a )
{
  int *x     = load_X() ;
  int y      = *( x + a ) ;
  // note that the use of sizeof() isn't required.  For the pointer carries around
  // an implicit increment size (the size of the object to which it points). The above
  // is equivalent to
  //
  //   int y = *(int*)((char*)x + (a*sizeof(*x)) ) ;
}

Further, the compiler will (or should) whine about type mismatches, given function foo():