什么是数据指针

A. 单片机中程序指针、数据指针、堆栈指针区别是什么

首先，你要明白一个概念，指针，是做什么的？答案是，指针，是指向地址的。
程序指针，指向的空间，在物理上是Flash，在逻辑上，就是代码空间。比如说51单片机的PC指针，指向的就是Flash,即程序下一步要执行的指令的地址。
数据指针，指向的空间，在物理上有Flash和RAM，在逻辑上是Flash里的常数空间和数据空间，注意，是对于单片机来说，对于我们的电脑，常数空间不是在Flash上。
比如说51单片机的DPTR，如果用MOVC
A,@A+DPTR，此时，就是指向常数空间，如果用
MOVX
A,@A+DPTR就是指向的数据空间。
堆栈指针，指向的空间，在物理上是RAM，在逻辑上，就是数据空间，是特定的数据空间，堆栈是数据空间中单独划分出来，专门用于寄存中间结果的内存空间。
数据指针和堆栈指针主要有两个区别：
一是数据指针可以指向Flash，即可以指向常数，比如说我们定义一个数组
unsigned
char
code
Table[99]，此时，就是DPTR可以指向常数空间。堆栈指针是不可以的，只能是指向RAM。
第二个区别，堆栈指针指向的是特定的数据空间，这个特定的数据空间，是从整个数据空间里划分出来，专门用于作堆栈用的，堆栈区间一旦划分出来，堆栈指针在规则上，就只能在这个范围内活动，如果出了这个范围，可能导致整个程序的崩溃。而数据指针在规则上，可以指向整个数据空间，但是，可以读堆栈空间，不应该去修改，否则也可能导致程序的崩溃。

B. 单片机里的 DPTR 和 PC 分别代表什么

1. DPTR数据指针

数据指针(DPTR)是某些单片机中一个功能比较特殊的寄存器，是一个16位的特殊功能寄存器， 其高位字节寄存器用DPH表示，低位字节寄存器用DPL表示，DPTR既可以作为一个16位的寄存器来处理，也可以作为两个独立的8位寄存器来使用。主要功能是存放16位地址，作为片外RAM寻址用的地址寄存器（间接寻址），故称数据指针，也可以将外部RAM中地址的内容传送到内部RAM的地址所指向的内容中。

2. PC程序指针：

PC——程序计数器，功能：用来指示下一条指令的地址（逻辑地址即偏移量），一般情况下，系统指示对其进行加1操作，担当遇到转移指令，如JMP,CALL，LOOP等时系统就会将跳转到的指令地址保存在PC中

C. 什么是指针

指针其实就是变量，只不过指针变量指向的不是某个具体的值，而是指向这个值所在的内存的地址.指针和其它变量一样，指针是基本的变量，所不同的是指针包含一个实际的数据，该数据代表一个可以找到实际信息的内存地址。这是一个非常重要的概念。许多程序和思想依靠指针作为他们设计的基础。

开始

怎样定义一个指针呢？除了你需要在变量的名称前面加一个星号外，其它的和别的变量定义一样。举个例子，以下代码定义了两个指针变量，它们都指向一个整数。

int* pNumberOne;

int* pNumberTwo;

注意到两个变量名称前的前缀’p’了么？这是一个惯例，用来表示这个变量是个指针。

现在，让我们将这些指针实际的指向某些东西：

pNumberOne = &some_number;

pNumberTwo = &some_other_number;

‘&’符号应该读作”什么什么的地址”，它返回一个变量在内存中的地址，设置到左侧的变量中。因此，在这个例子中，pNumberOne设置和some_number的地址相同，因此pNumberOne现在指向some_number。

现在，如果我们想访问some_number的地址，可以使用pNumberOne。如果我们想通过pNumberOne访问some_number的值，那么应该用*pNumberOne。这个星号表示解除指针的参照，应该读作“什么什么指向的内存区域”。

到现在我们学到了什么？举个例子

哟，有许多东西需要理解。我的建议是，如果你有哪个概念没有弄清楚的话，那么，不妨再看一遍。指针是个复杂的对象，可能需要花费一段时间来掌握它。

这儿有一个例子示范上面所将的概念。这是用C写的，没有C++扩展。

#include <stdio.h>

void main()

{

// 申明变量

int nNumber;

int *pPointer;

//赋值

nNumber = 15;

pPointer = &nNumber;

// 输出nNumber的值

printf("nNumber is equal to : %d\n", nNumber);

// 通过pPointer修改nNumber的值

*pPointer = 25;

// 证明nNumber已经被改变了

// 再次打印nNumber的值

printf("nNumber is equal to : %d\n", nNumber);

}

通读一遍，并且编译样例代码，确信你理解了它为什么这样工作。如果你准备好了，那么继续。

一个陷阱！

看看你能否发现下面这段程序的毛病：

#include <stdio.h>

int *pPointer;

void SomeFunction();

{

int nNumber;

nNumber = 25;

//将pPointer指向nNumber

pPointer = &nNumber;

}

void main()

{

SomeFunction(); //用pPointer做些事情

// 为什么会失败？

printf("Value of *pPointer: %d\n", *pPointer);

}

这段程序先调用SomeFunction函数，该函数创建一个叫做nNumber的变量，并将pPointer指向它。那么，问题是，当函数退出时，nNumber被删除了，因为它是一个局部变量。当程序执行到局部变量定义的程序块以外时，局部变量总是被删除了。这就意味着，当SomeFunction函数返回到main函数时，局部变量将被删除，因此pPointer将指向原先nNumber的地址，但这个地址已经不再属于这段程序了。如果你不理解这些，那么重新阅读一遍关于局部变量和全局变量的作用范围是明智的选择。这个概念也是非常重要的。

那么，我们如何解决这个问题呢？答案是使用大家都知道的一个方法：动态分配。请明白C和C++的动态分配是不同的。既然现在大多数程序员都使用C++，那么下面这段代码就是常用的了。

动态分配

动态分配可以说是指针的关键所在。不需要通过定义变量，就可以将指针指向分配的内存。也许这个概念看起来比较模糊，但是确实比较简单。下面的代码示范如何为一个整数分配内存：

int *pNumber;

pNumber = new int;

第一行申明了一个指针pNumber，第二行分配一个整数内存，并且将pNumber指向这个新内存。下面是另一个例子，这次用一个浮点数：

double *pDouble;

pDouble = new double;

动态分配有什么不同的呢？当函数返回或者程序运行到当前块以外时，你动态分配的内存将不会被删除。因此，如果我们用动态分配重写上面的例子，可以看到现在能够正常工作了。

#include <stdio.h>

int *pPointer;

void SomeFunction()

{

// make pPointer point to a new integer

pPointer = new int;

*pPointer = 25;

}

void main()

{

SomeFunction(); // make pPointer point to something

printf("Value of *pPointer: %d\n", *pPointer);

}

通读一遍，编译上面的代码，确信你已经理解它是如何工作的。当调用SomeFunction时，分配了一些内存，并且用pPointer指向它。这次，当函数返回时，新内存就完整无缺了。因此pPointer仍旧指向有用的东西。这是因为使用了动态分配。确信你已经理解它了。那么继续向下看，了解为什么上面的程序还会有一系列的错误。

内存分配和内存释放

这里有一个问题，可能会变得十分严重，虽然它很容易补救。这个问题就是，虽然你用动态分配可以方便的让内存完整无缺，确实不会自动删除，除非你告诉计算机，你不再需要这块内存了，否则内存将一直被分配着。因此结果就是，如果你不告诉计算机你已经使用完这块内存，那么它将成为被浪费的空间，因为其它程序或者你的应用程序的其它部分不能使用这块内存。最终将导致系统因为内存耗尽而崩溃。因此这个问题相当重要。内存使用完后释放非常容易：

delete pPointer;

需要做的就是这些。但是你必须确定，你删除的是一个指向你实际分配的内存的指针，而不是其它任何垃圾。尝试用delete已经释放的内存是危险的，并且可能导致程序崩溃。

这里再次举个例子，这次修改以后就不会有内存浪费了。

#include <stdio.h>

int *pPointer;

void SomeFunction()

{

// make pPointer point to a new integer

pPointer = new int;

*pPointer = 25;

}

void main()

{

SomeFunction(); // make pPointer point to something

printf("Value of *pPointer: %d\n", *pPointer);

delete pPointer;

}

只有一行不同，但这行是要点。如果你不删除内存，就会导致“内存泄漏”，内存将逐渐减少，除非应用程序重新启动，否则将不能再生。

向函数传递指针

传递指针给函数非常有用，但不容易掌握。如果我们写一个程序，传递一个数值并且给它加上5，我们也许会写出如下的程序：

#include <stdio.h>

void AddFive(int Number)

{

Number = Number + 5;

}

void main()

{

int nMyNumber = 18;

printf("My original number is %d\n", nMyNumber);

AddFive(nMyNumber);

printf("My new number is %d\n", nMyNumber);

}

但是，程序中函数AddFive的参数Number只是变量nMyNumber的一个拷贝，而不是变量本身，因此，Number = Number + 5只是为变量的拷贝增加了5，而不是最初的在main()函数中的变量。当然，你可以运行程序，以证明这一点。

为了将值传递出去，我们可以传递这个变量的指针到函数中，但我们需要修改一下函数，以便传递数值的指针而不是数值。因此将void AddFive(int Number)修改为void AddFive(int *Number)，增加了一个星号。下面是修改了的函数，注意，我们必须确认传递了nMyNumber的地址，而不是它本身。这通过增加&符号来完成，通常读作“什么什么的地址”。

#include <stdio.h>

void AddFive(int* Number)

{

*Number = *Number + 5;

}

void main()

{

int nMyNumber = 18;

printf("My original number is %d\n", nMyNumber);

AddFive(&nMyNumber);

printf("My new number is %d\n", nMyNumber);

}

大家可以试着自己做个例子来实验一下。注意在AddFive函数中Number变量前那个重要的星号。只是必须的，用来告诉编译器我们想将5加到变量Number指向的数值，而不是将5加到指针本身。

关于函数最后需要注意的是你也可以返回一个指针。比如：

int * MyFunction();

在这个例子中，MyFunction函数返回一个指向整数的指针。

类的指针

关于指针还有两个需要注意的问题。其中一个是结构或者类。你可以如下定义一个类：

class MyClass

{

public:

int m_Number;

char m_Character;

};

然后，你可以如下方式定义一个类变量：

MyClass thing;

你应该已经知道这些了，如果还不知道的话，那么再将上面的内容读一遍。定义MyClass的指针应该这么写：

MyClass *thing;

然后你需要分配内存，并将指针指向这个内存

thing = new MyClass;

问题来了，你如何使用这个指针呢？一般的，我们写thing.m_Number，但你不能对指针用’.’操作，因为thing不是一个MyClass对象。只是指向一个MyClass对象的指针。因此，指针thing不包含m_Number这个变量。只是它指向的结构中包含这个变量。因此，我们必须使用一个不同的协定，用->取代’.’。以下是一个例子：

class MyClass

{

public:

int m_Number;

char m_Character;

};

void main()

{

MyClass *pPointer;

pPointer = new MyClass;

pPointer->m_Number = 10;

pPointer->m_Character = 's';

delete pPointer;

}

数组的指针

你也可以构造一个指向数组的指针，如下：

int *pArray;

pArray = new int[6];

将创建一个叫做pArray的指针，指向一个包含6个元素的数组。另一种构造的方法是使用动态分配，如下：

int *pArray;

int MyArray[6];

pArray = &MyArray[0];

注意，你这里也可以不用&MyArray[0]，而直接使用&MyArray取代。当然，这仅仅适用于数组。

使用指向数组的指针

一旦你有了指向数组的指针，那么如何使用它呢？现在假设你有一个指向整数数组的指针，那么指针开始时将指向第一个整数。举例如下：

#include <stdio.h>

void main()

{

int Array[3];

Array[0] = 10;

Array[1] = 20;

Array[2] = 30;

int *pArray;

pArray = &Array[0];

printf("pArray points to the value %d\n", *pArray);

}

将指针移到指向数组的下一个值，可以用pArray++。也许你也可以猜出来了，我们可以用pArray+2的方式将指针向后移动两个位置。要注意的问题是，你自己必须知道数组的上限是多少（例子中是3），因为编译器不能检查你是否将指针移到了数组以外，因此你可以很容易的将系统搞崩溃了。以下是个例子，显示我们设置的三个值：

#include <stdio.h>

void main()

{

int Array[3];

Array[0] = 10;

Array[1] = 20;

Array[2] = 30;

int *pArray;

pArray = &Array[0];

printf("pArray points to the value %d\n", *pArray);

pArray++;

printf("pArray points to the value %d\n", *pArray);

pArray++;

printf("pArray points to the value %d\n", *pArray);

}

你也可以使用pArray-2这样的方式来向前移动2个位置。不管是加或者减，你必须保证不是对指针所指向的数据的操作。这种操作指针和数组的方式在循环中是最常用的。例如for和while循环。

另外要提的是，如果你有一个指针比如int pNumberSet，你也可以把它当成数组。例如pNumberSet[0]等于*pNumberSet，并且pNumberSet[1]等于*(pNumberSet+1)。

对于数组，还有一点要注意的，如果你用new为数组分配内存，比如：

int *pArray;

pArray = new int[6];

你必须用以下方式进行删除：

delete[] pArray;

注意delete后的[]，它告诉编译器，这是删除整个数组，而不仅仅是第一个元素。对于数组你必须使用这种方法，否则就会有内存泄漏。

总结

一条要注意的：你不能删除不是用new分配的内存。比如以下例子：

void main()

{

int number;

int *pNumber = number;

delete pNumber; // wrong - *pNumber wasn't allocated using new.

}

D. C语言指针基本概念及其指针变量的定义是什么

指针是常见间接访问方式．指针就像一个快捷方式，它指向内存的一个地址，可以通过指针就可以间接的访问到数据。对于计算机，访问内存的方式有两种，直接访问和间接访问。直接访问通过就是通过变量名称去访问。指针概念是构成C/C++的重要元素之一，是变量的一种类型，存放的是指定类型数据的地址，而同类型变量存放的是数据。

指针变量：就是一个变量，其值是可变的，与整形变量、浮点变量等等的命名规则完全相同。 “指针”是概念，“指针变量”是具体实现。指针类型说明，即定义变量为一个指针变量; 指针变量名; 变量值(指针)所指向的变量的数据类型。

(4)什么是数据指针扩展阅读：

与其他高级编程语言相比，C 语言可以更高效地对计算机硬件进行操作，而计算机硬件的操作指令，在很大程度上依赖于地址。指针提供了对地址操作的一种方法，因此，使用指针可使得 C 语言能够更高效地实现对计算机底层硬件的操作。另外，通过指针可以更便捷地操作数组。在一定意义上可以说，指针是 C 语言的精髓。

E. 什么是指针数据类型

指针是一种变量，和整型呀浮点型一样
不同的是，指针变量里面存储的是一个变量的地址
比如整型指针存储的是一个整型变量的存储地址
最终要说的是，指针数据类型就是一种数据类型，没什么特殊的
只不过整型变量存储的是整数
指针变量存储的是地址

F. 指针与指针变量的概念是什么

1、指针，是C语言中的一个重要概念及其特点，也是掌握C语言比较困难的部分。指针也就是内存地址，指针变量是用来存放内存地址的变量，不同类型的指针变量所占用的存储单元长度是相同的，而存放数据的变量因数据的类型不同，所占用的存储空间长度也不同。

有了指针以后，不仅可以对数据本身，也可以对存储数据的变量地址进行操作。

2、指针变量是指存放地址的变量。因地址的改变而做出指定性质的衡量变法。

(6)什么是数据指针扩展阅读：

指针变量定义：

1、定义指针变量的一般形式如下：

类型名*指针变量名1，*指针变量名2，... *指针变量名n ;

2、空指针

空指针是一个特殊的指针，它的值是0，C语言中用符号常量NULL（在stdio.h中定义）表示这个空值，并保证这个值不会是任何变量的地址。空指针对任何指针类型赋值都是合法的。一个指针变量具有空指针值表示当前它没有指向任何有意义的东西。

3、void指针

（void *）类型的指针叫通用指针，可以指向任何的变量，C语言允许直接把任何变量的地址作为指针赋给通用指针。

但是需要注意void*不能指向由const修饰的变量，例如const int test; void * ptv; ptv = &test;第三句是非法的，只有将ptv声明为const void * ptv;，上述第三句ptv = &test才是合法的。

当需要使用通用指针所指的数据参加运算时，需要写出类型强制转换。如通用指针ptv 所指空间的数据是整型数据，p是整型指针，用此式转换：p=(int *)ptv;

G. 数据库的指针是什么

数据库里没有指针
有游标。
游标是映射在结果集中一行数据上的位置实体，有了游标，用户就可以访问结果集中的任意一行数据了，将游标放置到某行后，即可对该行数据进行操作。
1. 声明游标
CURSOR mycur(vartype number) is
select emp_no,emp_zc from cus_emp_basic
where com_no = vartype;

2. 打开游标
open mycur(000627)
注：000627是参数

3. 读取数据
fetch mycur into varno, varprice;

4. 关闭游标
close mycur;

H. 什么是指针

指针是C语言里面的一个重要概念,也是C语言的难点之一.指针可以表示许多复杂的数据结构,如队列,栈,链表,树,图等.
要学习指针,应该先了解以下几个概念:变量的地址,变量的内容,直接寻址,间接寻址.
变量的地址:变量在内存中所占存储空间的首地址.
变量的内容:变量在内存的存储单元中存放的数据.
如:
int a=10;//两个字节
假设a占的内存单元的地址为:2020和2021
则内存单元的地址为2020的是存放数据a(即10)的低字节,内存单元的地址为2021的是存放数据a即10)的高字节.
如果将变量a的首地址2020保存到另一个变量p中,那么为了访问变量a,我们可以通过变量p得到a的的地址2020,再到该地址中访问变量a.

直接寻址:直接按变量名来存取变量的内容的访问方式.
专门用于存放地址型数据的变量是指针变量,如上面所说的p.
间接寻址:通过指针变量(如P)间接存取它所指向的变量(如a)的访问方式称为间接寻址.
在上例中,a的地址用&a表示.由于p是保存地址型数据的,所以p=a的地址=&a
在此p就叫做指针(或指针变量)
其定义如下:
int *p;
指针有好多好处:
1.为函数提供修改变量值的手段.
2.为C的动态内存分配提供支持.
3.为动态数据结构提供支持.
4.可以改善程序的效率.

I. 单片机中程序指针 数据指针 堆栈指针区别

首先，你要明白一个概念，指针，是做什么的？答案是，指针，是指向地址的。
程序指针，指向的空间，在物理上是Flash，在逻辑上，就是代码空间。比如说51单片机的PC指针，指向的就是Flash,即程序下一步要执行的指令的地址。

数据指针，指向的空间，在物理上有Flash和RAM，在逻辑上是Flash里的常数空间和数据空间，注意，是对于单片机来说，对于我们的电脑，常数空间不是在Flash上。
比如说51单片机的DPTR，如果用MOVC A,@A+DPTR，此时，就是指向常数空间，如果用
MOVX A,@A+DPTR就是指向的数据空间。

堆栈指针，指向的空间，在物理上是RAM，在逻辑上，就是数据空间，是特定的数据空间，堆栈是数据空间中单独划分出来，专门用于寄存中间结果的内存空间。

数据指针和堆栈指针主要有两个区别：
一是数据指针可以指向Flash，即可以指向常数，比如说我们定义一个数组 unsigned char code Table[99]，此时，就是DPTR可以指向常数空间。堆栈指针是不可以的，只能是指向RAM。

第二个区别，堆栈指针指向的是特定的数据空间，这个特定的数据空间，是从整个数据空间里划分出来，专门用于作堆栈用的，堆栈区间一旦划分出来，堆栈指针在规则上，就只能在这个范围内活动，如果出了这个范围，可能导致整个程序的崩溃。而数据指针在规则上，可以指向整个数据空间，但是，可以读堆栈空间，不应该去修改，否则也可能导致程序的崩溃。