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

The problem with C++ constructs that people generally use to replace pointers are very dependent on the toolset that you use which is fine when you have all the control you need over the source code, however if you compile a static library with visual studio 2008 for instance and try to use it in a visual studio 2010 you will get a ton of linker errors because the new project is linked with a newer version of STL which is not backwards compatible. Things get even nastier if you compile a DLL and give an import library that people use in a different toolset because in that case your program will crash sooner or later for no apparent reason.

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

Another good reason to use pointers in C++ again relates to libraries, consider having a dll that cannot be loaded when your program runs, so if you use an import library then the dependency isn't satisfied and the program crashes. This is the case for instance when you give a public api in a dll alongside your application and you want to access it from other applications. In this case in order to use the API you need to load the dll from its' location (usually it's in a registry key) and then you need to use a function pointer to be able to call functions inside the DLL. Sometimes the people that make the API are nice enough to give you a .h file that contain helper functions to automate this process and give you all the function pointers that you need, but if not you can use LoadLibrary and GetProcAddress on windows and dlopen and dlsym on unix to get them (considering that you know the entire signature of the function).

Pointers allow you to refer to the same space in memory from multiple locations. This means that you can update memory in one location and the change can be seen from another location in your program. You will also save space by being able to share components in your data structures. You should use pointers any place where you need to obtain and pass around the address to a specific spot in memory. You can also use pointers to navigate arrays: An array is a block of contiguous memory that has been allocated with a specific type. The name of the array contains the value of the starting spot of the array. When you add 1, that takes you to the second spot. This allows you to write loops that increment a pointer that slides down the array without having an explicit counter for use in accessing the array.

下面是一个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。

因为到处复制大对象会浪费时间和内存。

指针的一种用途(我不会提及在其他人的文章中已经介绍过的内容)是访问未分配的内存。这对于PC编程来说没什么用，但是在嵌入式编程中用于访问内存映射的硬件设备。

在DOS的旧时代，你可以通过声明一个指针直接访问显卡的显存:

unsigned char *pVideoMemory = (unsigned char *)0xA0000000;

许多嵌入式设备仍然使用这种技术。

让我也试着回答这个问题。

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

首先，在处理嵌入式硬件时，通常必须大量使用指针。也许你需要切换数字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++技能就越可移植。

From a maintainability point of view, I should also mention that when you do use pointers, you either have to test for their validity and handle the case when they're not valid, or, just assume they are valid and accept the fact that your program will crash or worse WHEN that assumption is broken. Put another way, your choice with pointers is to either introduce code complexity or more maintenance effort when something breaks and you're trying to track down a bug that belongs to a whole class of errors that pointers introduce, like memory corruption.

因此，如果您控制所有代码，请远离指针，而使用引用，尽可能将它们保持为const。这将迫使您考虑对象的生命周期，并最终使您的代码更容易理解。

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

所以我是说不可能创建无效引用吗?不。这是完全可能的，因为c++几乎可以让你做任何事情。只是在无意中更难做到，你会惊讶于有多少bug是无意的:)

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

The problem with C++ constructs that people generally use to replace pointers are very dependent on the toolset that you use which is fine when you have all the control you need over the source code, however if you compile a static library with visual studio 2008 for instance and try to use it in a visual studio 2010 you will get a ton of linker errors because the new project is linked with a newer version of STL which is not backwards compatible. Things get even nastier if you compile a DLL and give an import library that people use in a different toolset because in that case your program will crash sooner or later for no apparent reason.

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

Another good reason to use pointers in C++ again relates to libraries, consider having a dll that cannot be loaded when your program runs, so if you use an import library then the dependency isn't satisfied and the program crashes. This is the case for instance when you give a public api in a dll alongside your application and you want to access it from other applications. In this case in order to use the API you need to load the dll from its' location (usually it's in a registry key) and then you need to use a function pointer to be able to call functions inside the DLL. Sometimes the people that make the API are nice enough to give you a .h file that contain helper functions to automate this process and give you all the function pointers that you need, but if not you can use LoadLibrary and GetProcAddress on windows and dlopen and dlsym on unix to get them (considering that you know the entire signature of the function).