c++ - 有指针吗 - 为什么要用指针




为什么要使用指针? (12)

我知道这是一个非常基本的问题,但是我在用高级语言编写几个项目之后才开始使用一些基本的C ++编程。

基本上我有三个问题:

  1. 为什么使用指针超过正常变量?
  2. 何时何地应该使用指针?
  3. 你如何使用数组指针?

  1. 指针允许您从多个位置引用内存中相同的空间。 这意味着您可以在一个位置更新内存,并且可以从程序中的其他位置看到更改。 您还可以通过共享数据结构中的组件来节省空间。
  2. 您应该在需要获取的地方使用指针,并将地址传递给内存中的特定地点。 您还可以使用指针来导航数组:
  3. 一个数组是一个连续内存块,已经被分配了一个特定的类型。 数组的名称包含数组的起始点的值。 当您添加1时,会将您带到第二个位置。 这允许你编写循环来递增一个沿着数组向下滑动的指针,而不需要一个明确的计数器来访问数组。

这里是C中的一个例子:

char hello[] = "hello";

char *p = hello;

while (*p)
{
    *p += 1; // increase the character by one

    p += 1; // move to the next spot
}

printf(hello);

版画

ifmmp

因为它取得每个角色的值并将其加1。


here描述here C语言中指针的需求

基本思想是可以通过处理数据的内存位置来消除语言中的许多限制(如使用数组,字符串和修改函数中的多个变量)。 为了克服这些限制,在C中引入了指针。

此外,还可以看到,使用指针有时可以更快地运行代码并节省内存(在将大数据类型(比如结构)传递给函数的情况下,在传递之前复制这些数据类型需要时间和会消耗内存)。 这是程序员更喜欢大数据类型指针的另一个原因。

PS:请参考herehere以获取详细解释和示例代码。


使用指针的一个原因是可以在被调用函数中修改变量或对象。

在C ++中,使用引用比指针更好。 尽管引用实际上是指针,但C ++在一定程度上隐藏了事实,并使得它看起来好像是按值传递的。 这可以很容易地改变调用函数接收值的方式,而无需修改传递它的语义。

考虑下面的例子:

使用参考:

public void doSomething()
{
    int i = 10;
    doSomethingElse(i);  // passes i by references since doSomethingElse() receives it
                         // by reference, but the syntax makes it appear as if i is passed
                         // by value
}

public void doSomethingElse(int& i)  // receives i as a reference
{
    cout << i << endl;
}

使用指针:

public void doSomething()
{
    int i = 10;
    doSomethingElse(&i);
}

public void doSomethingElse(int* i)
{
    cout << *i << endl;
}

关于你的第二个问题,通常你不需要在编程时使用指针,但是有一个例外,那就是当你创建一个公共API时。

人们通常用来替换指针的C ++构造的问题非常依赖于您使用的工具集,当您通过源代码获得所有需要的控件时,这是很好的,但是如果您编译了一个静态库,例如Visual Studio 2008并尝试在Visual Studio 2010中使用它,你将会得到大量的链接器错误,因为新项目与更新版本的STL链接,该STL不向后兼容。 如果你编译一个DLL并给出一个人们在不同的工具集中使用的导入库,情况会变得更加糟糕,因为在那种情况下,你的程序迟早会无缘无故地崩溃。

因此,为了将大型数据集从一个库移动到另一个库,如果您不想强制其他人使用您使用的相同工具,则可以考虑将数组指针指向应该复制数据的函数。 关于这一点的好处是,它甚至不必是C风格的数组,你可以使用std :: vector并通过给出第一个元素&vector [0]的地址作为指针,并使用std :: vector在内部管理数组。

在C ++中使用指针的另一个好的理由又与库有关,考虑有一个DLL在程序运行时无法加载,所以如果你使用一个导入库,那么这个依赖不会被满足,程序就会崩溃。 例如,当您在应用程序旁边提供一个公共API时,并且您想从其他应用程序访问它时,就是这种情况。 在这种情况下,为了使用API​​,您需要从其位置(通常位于注册表项)中加载DLL,然后您需要使用函数指针来调用DLL中的函数。 有时候,制作API的人可以给你一个.h文件,该文件包含帮助函数来自动执行这个过程,并为你提供所有你需要的函数指针,但是如果没有的话,你可以在windows和dlopen上使用LoadLibrary和GetProcAddress, dlsym在unix上得到它们(考虑到你知道函数的整个签名)。


在C ++中,如果你想使用子类型polymorphism ,你必须使用用户指针。 看到这篇文章: 没有指针的C ++多态 。

真的,当你考虑它时,这是有道理的。 当你使用子类型多态时,最终你不会提前知道调用哪个类或子类的方法实现,因为你不知道实际的类是什么。

这个拥有一个包含未知类对象的变量的想法与C ++在堆栈中存储对象的默认(非指针)模式不兼容,其中分配的空间量直接对应于该类。 注意:如果一个类有5个实例字段而不是3个,则需要分配更多空间。

请注意,如果您使用'&'通过引用传递参数,则间接(即指针)仍然涉及幕后。 '&'只是语法糖(1)为您节省了使用指针语法的麻烦,并且(2)允许编译器更严格(如禁止空指针)。


在java和C#中,所有的对象引用都是指针,使用c ++的事情是你可以更多地控制指针指向的地方。 记住伟大的力量来自宏伟的责任。


指针在许多数据结构中很重要,其设计需要能够有效地将一个“节点”链接或链接到另一个“节点”。 你不会“选择”一个指针,而是说像float这样的普通数据类型,它们只是有不同的目的。

指针在需要高性能和/或紧凑内存占用的情况下非常有用。

数组中第一个元素的地址可以分配给一个指针。 这可以让你直接访问底层分配的字节。 数组的全部意义在于避免你需要这样做。


指针是间接引用另一个变量的一种方法。 他们没有保留变量的 ,而是告诉你它的地址 。 这在处理数组时尤其有用,因为使用指向数组中第一个元素的指针(其地址),您可以通过递增指针(到下一个地址位置)快速找到下一个元素。

我读过的指针和指针算术的最佳解释是K&R的The C Programming Language 。 开始学习C ++的好书是C ++ Primer


指针被使用,因为在动态堆区域的数据分配和回复中性能增加。


让我试着回答这个问题。

指针与引用类似。 换句话说,它们不是副本,而是一种参考原始值的方式。

在别的之前,在你处理嵌入式硬件时, 你通常必须使用指针的地方很多。 也许你需要切换数字IO引脚的状态。 也许你正在处理一个中断,并需要在特定位置存储一个值。 你得到的照片。 但是,如果您不直接处理硬件,只想知道要使用哪种类型,请继续阅读。

为什么使用指针而不是正常变量? 当你处理复杂的类型时,答案会变得更加清晰,比如类,结构和数组。 如果你使用一个普通的变量,你最终可能会做一个副本(编译器足够聪明以防止在某些情况下出现这种情况,而C ++ 11也可以提供帮助,但我们暂时不会讨论这个问题)。

现在如果你想修改原始值会发生什么? 你可以使用这样的东西:

MyType a; //let's ignore what MyType actually is right now.
a = modify(a); 

这将工作得很好,如果你不知道你为什么使用指针,你不应该使用它们。 小心“他们可能更快”的原因。 运行自己的测试,如果他们真的更快,然后使用它们。

但是,假设您正在解决需要分配内存的问题。 当你分配内存时,你需要释放它。 内存分配可能会也可能不会成功。 这就是指针有用的地方 - 它允许你测试你已经分配的对象的存在,并且允许你通过去引用指针来访问分配内存的对象。

MyType *p = NULL; //empty pointer
if(p)
{
    //we never reach here, because the pointer points to nothing
}
//now, let's allocate some memory
p = new MyType[50000];
if(p) //if the memory was allocated, this test will pass
{
    //we can do something with our allocated array
    for(size_t i=0; i!=50000; i++)
    {
        MyType &v = *(p+i); //get a reference to the ith object
        //do something with it
        //...
    }
    delete[] p; //we're done. de-allocate the memory
}

这是你使用指针的关键 - 引用假定你引用的元素已经存在 。 指针没有。

为什么要使用指针(或者至少最终不得不处理它们)的另一个原因是因为它们是引用之前存在的数据类型。 因此,如果你最终使用库来完成你知道他们擅长的事情,你会发现很多这些库在各处都使用指针,只是因为他们已经存在了多长时间(很多他们是在C ++之前编写的)。

如果你没有使用任何库,你可以设计你的代码,使你可以远离指针,但是鉴于指针是语言的基本类型之一,使用它们越快舒适,可移植你的C ++技能。

从可维护性的角度来看,我还应该提到,当你使用指针时,你必须测试它们的有效性,并在它们无效时处理这种情况,或者,假设它们是有效的并接受事实当这个假设被打破时,程序将会崩溃或更糟。 换句话说, 用指针选择是为了在出现问题时引入代码复杂性或更多的维护工作,并且试图追踪属于指针引入的整个类错误(如内存损坏)的错误。

所以,如果你控制了所有的代码,远离指针,而是使用引用,当你可以的时候保持它们为const。 这将迫使您考虑对象的生命周期,并最终让代码更易于理解。

请记住这个区别: 引用本质上是一个有效的指针。 指针并不总是有效的。

那么我是说它不可能创建一个无效的参考? 不,它完全可能,因为C ++可以让你做任何事情。 只是无意间做更难,你会惊讶于有多少错误是无意的:)


这里有一点略有不同,但深入探讨为什么C的许多功能是有意义的: http://steve.yegge.googlepages.com/tour-de-babel#C : http://steve.yegge.googlepages.com/tour-de-babel#C

基本上,标准的CPU体系结构是冯诺依曼体系结构,能够在内存中引用数据项的位置,并在此类机器上进行算术运算,这是非常有用的。 如果你知道汇编语言的任何变体,你很快就会看到这是低级别的关键。

C ++使指针有点混乱,因为它有时会为你管理它们并以“引用”的形式隐藏它们的效果。 如果使用直C,则对指针的需求会更加明显:没有其他方法可以通过引用进行调用,这是存储字符串的最佳方式,它是迭代数组的最佳方式等。


  • 为什么使用指针超过正常变量?

简短的回答是:不要。 ;-)指针将被用于你不能使用其他任何东西的地方。 这要么是因为缺乏适当的功能,缺少数据类型或纯粹的性能。 更多下面...

  • 何时何地应该使用指针?

这里简短的回答是:你不能使用其他任何东西。 在C中,您不支持复杂的数据类型,如字符串。 也没有办法将一个变量“通过引用”传递给一个函数。 这就是你必须使用指针的地方。 你也可以让他们指向几乎任何东西,链表,结构成员等等。 但是,我们不要在这里进入。

  • 你如何使用数组指针?

没有多少努力和很多困惑。 ;-)如果我们谈论诸如int和char这样的简单数据类型,那么数组和指针之间几乎没有区别。 这些声明非常相似(但不一样 - 例如, sizeof将返回不同的值):

char* a = "Hello";
char a[] = "Hello";

你可以像这样到达数组中的任何元素

printf("Second char is: %c", a[1]);

索引1,因为数组以元素0开始。:-)

或者你也可以这样做

printf("Second char is: %c", *(a+1));

指针操作符(*)是必需的,因为我们告诉printf我们要打印一个字符。 如果没有*,则会打印内存地址本身的字符表示。 现在我们正在使用角色本身。 如果我们使用了%s而不是%c,我们会要求printf打印由'a'指向的内存地址的内容加上一个(在上面的例子中),我们不必将*前面:

printf("Second char is: %s", (a+1)); /* WRONG */

但是,这不会仅仅打印第二个字符,而是打印下一个内存地址中的所有字符,直到找到空字符(\ 0)。 这就是事情开始变得危险的地方。 如果您不小心尝试使用%s格式化程序打印类型为integer的变量而不是字符指针?

char* a = "Hello";
int b = 120;
printf("Second char is: %s", b);

这将打印内存地址120上找到的内容,并继续打印直到找到空字符。 执行此printf语句是错误的和非法的,但无论如何它可能会起作用,因为在许多环境中指针实际上是int类型的。 想象一下,如果你使用sprintf()而不是使用sprintf(),可能会导致这些问题,并将这种方式分配给另一个变量的“char数组”过长,只能分配一定的空间。 你很可能最终会写内存中的其他内容,并导致你的程序崩溃(如果你幸运的话)。

哦,如果你在声明它的时候没有给字符数组/指针赋一个字符串值,那么在给它一个值之前,你必须给它分配足够的内存。 使用malloc,calloc或类似的。 这是因为你只声明了你的数组中的一个元素/一个单一的内存地址指向。 这里有几个例子:

char* x;
/* Allocate 6 bytes of memory for me and point x to the first of them. */
x = (char*) malloc(6);
x[0] = 'H';
x[1] = 'e';
x[2] = 'l';
x[3] = 'l';
x[4] = 'o';
x[5] = '\0';
printf("String \"%s\" at address: %d\n", x, x);
/* Delete the allocation (reservation) of the memory. */
/* The char pointer x is still pointing to this address in memory though! */
free(x);
/* Same as malloc but here the allocated space is filled with null characters!*/
x = (char *) calloc(6, sizeof(x));
x[0] = 'H';
x[1] = 'e';
x[2] = 'l';
x[3] = 'l';
x[4] = 'o';
x[5] = '\0';
printf("String \"%s\" at address: %d\n", x, x);
/* And delete the allocation again... */
free(x);
/* We can set the size at declaration time as well */
char xx[6];
xx[0] = 'H';
xx[1] = 'e';
xx[2] = 'l';
xx[3] = 'l';
xx[4] = 'o';
xx[5] = '\0';
printf("String \"%s\" at address: %d\n", xx, xx);

请注意,在执行完分配内存的free()之后,仍然可以使用变量x,但不知道里面有什么。 另外请注意,两个printf()可能会给你不同的地址,因为不能保证第二次分配的内存是在与第一次分配相同的空间中执行的。





pointers