变量

指针其实就是变量存放的地址。 int a = 5; int *p = &a; p指针就指向了a变量，&是单目运算符，取变量地址的。 然后就可以通过p指针来访问a变量了

可以这么理解,指针指向的是一个地址,但这个地址里面可能是一个变量,也可以是个常量,或者是其它类型...

指针变量是变量，用于存放指针，或者说存放地址变量指针是指针，是变量的地址指针变量可以存放变量的指针，存放了变量的指针的指针变量可以访问那个变量的存储区，间接地修改或读取它的值

你可以定义指向指针的指针int a = 1;int *ptr = &a;int **ptr_to_ptr = &ptr;

B

我一直在承受这个年纪不该有的帅气和机智，我好累

指针变量是变量的一种，指针变量的值是地址（也是整数）。普通变量的值是整数或者实数。指针变量可以将存储地址的变量和存储普通整数的变量区分开来。指针变量的作用主要是用来修改其他函数的局部变量或者用来访问数组。指针变量需要额外的空间存放地址，由于是间接访问所指对象所以比起直接用名字访问所指对象而言，速度稍慢。指针变量的这些开销根本无需考虑，正确使用就行了。

用例子来看一下。int a=3;int *p;p=&a;现在来看一下。a=3这个式子先解释一下等式右边是常量，左边是变量。同理的p=&a，左边的是指针变量，右边的是指针指针的基本概念：为了区别内存的不同位置，内存被分成字节，内存的全部字节顺序地赋予一个称为地址的编号。程序中的变量将在内存中占据一定的内存字节，在这些字节中存储的数据信息称为变量的内容。一个变量占用连续的若干个内存字节时，最前面的一个字节的地址就作为该变量的地址。指针就是内存地址，是变量的地址，或函数的入口地址。变量的地址在程序执行时，起着非常重要的作用。当计算机在计算含有变量的表达式时，计算机按变量的地址取出其内容，并按变量的地址将计算结果存入到变量占据的内存中。如代码：　　int x＝l；　　x＝x＋2；　　其中语句“x＝x＋2；”中的第一个x涉及到变量x占据的内存，第二个 x是引用变量 x的内容。该语句的意义是“取X的内容，完成加上2的计算，并将计算结果存入变量X占据的内存中。”　　指针变量和它所指向的变量：在C语言中，地址也作为一种值，能被存储、比较、赋值，并称地址数据为指针类型，而称存储地址值的变量为指针变量，简称指针。C程序可用运算符＆取变量的地址，如表达式＆x的值就是变量X的地址。程序除能按名引用变量外，也可利用变量的地址引用变量。按变量名引用变量称为直接引用，而将变量A的地址存于另一变量B中，借助于变量B引用变量A称为对A的间接引用。　　定义指针变量的一般形式为：　　类型 * 指针变量名；　　或　　类型 * 指针变量名=初值表达式；　　其中，指针变量名是标识符，指针变量名之前的符号“*”，表示该变量是指针类型的。而最前面的“类型”，表示该指针变量能指向变量或函数的类型。初值表达式是一个地址表达式，如表达式中有某变量的地址表达式，则这个变量应是前面已定义的。　　在C语言中，当定义局部指针变量时，如未给它指定初值，则其值是不确定的。程序在使用它们时，应首先给它们赋值。误用其值不确定的指针变量间接引用其它变量，会引起意想不到的错误。为明确表示指针变量不指向任何变量，在C语言中用0值表示这种情况，记为NULL。如　　ip＝ NULL;　　也称指针值为0的指针变量为空指针。对于静态的指针变量，如在定义时未给它指定初值，系统自动给它指定初值0。　　指针变量取程序对象的（开始）地址值，不能将一个整型量或任何其它非地址值赋给一个指针变量。另外，指针变量对所指向的对象也有类型限制，不能将一个不能指向的对象的地址赋给指针变量。如有以下定义：　　int i＝100，j，*ip，*intpt；　　float f,*fp；　　以下代码如注释所叙。　　iP＝&i；/*使ip指向i*/　　intpt＝ip；/*使intpt指向ip所指变量*/　　fp= &f；/*使fp指向正*/　　ip＝NULL；/*使 ip不再指向任何变量*/拓展资料：在计算机科学中，指针(Pointer)是编程语言中的一个对象，利用地址，它的值直接指向(points to)存在电脑存储器中另一个地方的值。由于通过地址能找到所需的变量单元，可以说，地址指向该变量单元。因此，将地址形象化的称为"指针"。意思是通过它能找到以它为地址的内存单元。 在高级语言中，指针有效地取代了在低级语言，如汇编语言与机器码，直接使用通用暂存器的地方，但它可能只适用于合法地址之中。指针参考了存储器中某个地址，通过被称为反参考指针的动作，可以取出在那个地址中存储的值。作个比喻，假设将电脑存储器当成一本书，一张内容记录了某个页码加上行号的便利贴，可以被当成是一个指向特定页面的指针;根据便利粘贴面的页码与行号，翻到那个页面，把那个页面的那一行文字读出来，就相当于是对这个指针进行反参考的动作。指针是程序设计语言的一个重要概念。指针在C程序中有以下多方面的作用：　　利用指针能间接引用它所指的对象。　　利用各种类型的指针形式参数，能使函数增加描述能力。　　指针与数组结合，使引用数组元素的形式更加多样、访问数组元素的手段更加灵活。　　指针能用来描述数据和数据之间的关系，以便构造复杂的数据结构。当一个数据A要关联另一个数据B时，在数据A中增加一个指向数据B的指针就可实现数据A关联数据B。结合系统提供的动态分配存储设施，又能构造出各种动态数据结构。

变量的指针就是变量的地址，比如说变量i在内存中的地址为2000，那么他的指针就是2000；而不是2000这个地址中所存放的i的内容。

变量的指针就是变量的地址。存放变量地址的变量是指针变量。允许用一个变量来存放指针，这种变量称为指针变量。因此，一个指针变量的值就是某个变量的地址或称为某变量的指针 比如: int a;//变量 int *p;//指针变量 p=&a;//p就是变量a的指针,你可以叫它变量指针

指针变量 合法的赋值 只有地址值。 如果填两个的话 就是地址值和空值 也就是NULL很多人说地址值和变量值， 后者 是不对的。

p中存地址 *p指 p地址指向的内容 a 直接就是值

比较严格的说法是这样的：系统为每一个内存单元分配一个地址值，C/C++把这个地址值称为“指针”。如有int i=5;，存放变量i的内存单元的编号(地址)&i被称为指针。“指针变量”则是存放前述“地址值”的变量，也可以表述为，“指针变量”是存放变量所占内存空间“首地址”的变量(因为一个变量通常要占用连续的多个字节空间)。比如在int i=5;后有一句int *p=&i;，就把i的指针&i赋给了int *型指针变量p，也就是说p中存入着&i。所以说指针变量是存放指针的变量。有一个事实值得注意，那就是有不少资料和教科书并没有如上区分，而是认为“指针是指针变量的简称”，如对int *p=&i;的解释是：声明一个int *型指针p，并用变量i的地址初始化；而严格说应该是声明一个int *型指针变量p才对。所以有时看书要根据上下文理解实质，而不能过于拘泥于文字表述。

前者是变量，后者是常量，指针变量很显然这个指针指向的存储单元存储的数据是可以变化的和指针常量指向的数据是程序运行前定义的一个不会变化的量，在程序运行过程中，这个量既不能改变大小，也不能改变类型。

变量的指针，其含义是指该变量的地址。存放地址的变量称为指针变量，指针变量是一种特殊的变量，它不同于一般的变量，一般变量存放的是数据本身，而指针变量存放的是数据的地址。举例：int a = 68 ,系统为变量a分配的首地址为0X065FDF4H，声明空指针long *p = NULL，p=&a是存放变量a地址的指针变量，即p=&a中存放的值为0x065FDF4H（a的值为68，&a的值为0x065FDF4H）。扩展资料：对变量a的访问有两种方式：一是直接按地址0x065FDF4H找到a的存储单元，从而对变量a进行访问；二是按系统为p=&a分配的地址先找到p=&a，然后根据p，&a的值（即变量a地址0x065FDF4H）找到变量a在内存中的存储单元，从而对变量a进行访问。对于前一种访问方式称为直接访问方式，后一种访问方式称为间接访问方式。如果一个指针变量存放的是某个对象的地址，则称这个指针变量指向该对象。在C++程序设计中，指针变量只有确定了指向才有意义。

指针变量的一般定义为: 类型标识符 *标识符; 其中标识符是指针变量的名字, 标识符前加了*号,表示该变量是指针变量, 而最前面的类型标识符表示该指针变量所指向的变量的类型。一个指针变量只能指向同一种类型的变量, 也就是讲, 我们不能定义一个指针变量, 既能指向一整型变量又能指向双精度变量。

指针是C语言的精华部分，通过利用指针，我们能很好地利用内存资源，使其发挥最大的效率。有了指针技术，我们可以描述复杂的数据结构，对字符串的处理可以更灵活，对数组的处理更方便，使程序的书写简洁，高效，清爽。但由于指针对初学者来说，难于理解和掌握，需要一定的计算机硬件的知识做基础，这就需要多做多练，多上机动手，才能在实践中尽快掌握，成为C的高手。过去，我们在编程中定义或说明变量，编译系统就为已定义的变量分配相应的内存单元，也就是说，每个变量在内存会有固定的位置，有具体的地址。由于变量的数据类型不同，它所占的内存单元数也不相同。若我们在程序中做定义为：int a=1,b=2;float x=3.4, y = 4 . 5 ;double m=3.124;char ch1="a", ch2="b";让我们先看一下编译系统是怎样为变量分配内存的。变量a,b是整型变量，在内存各占2个字节；x,y是实型，各占4个字节；m是双精度实型，占8个字节；ch1,ch2是字符型，各占1个字节。由于计算机内存是按字节编址的，设变量的存放从内存2000单元开始存放，则编译系统对变量在内存的安放情况为图6-1所示。变量在内存中按照数据类型的不同，占内存的大小也不同，都有具体的内存单元地址，如变量a在内存的地址是2000，占据两个字节后，变量b的内存地址就为2002，变量m的内存地址为2012等。对内存中变量的访问，过去用scanf("%d%d%f",&a,&b,&x)表示将数据输入变量的地址所指示的内存单元。那么，访问变量，首先应找到其在内存的地址，或者说，一个地址唯一指向一个内存变量，我们称这个地址为变量的指针。如果将变量的地址保存在内存的特定区域，用变量来存放这些地址，这样的变量就是指针变量，通过指针对所指向变量的访问，也就是一种对变量的“间接访问”。设一组指针变量pa、pb、px、py、pm、pch1、pch2，分别指向上述的变量a、b、x、y、m、ch1、ch2，指针变量也同样被存放在内存，二者的关系如图6-2所示：在图6-2中，左部所示的内存存放了指针变量的值，该值给出的是所指变量的地址，通过该地址，就可以对右部描述的变量进行访问。如指针变量pa的值为2000，是变量a在内存的地址。因此，pa就指向变量a。变量的地址就是指针，存放指针的变量就是指针变量。

1、概念不同“指针”是概念，“指针变量”是具体实现，指针也是一个变量，所以需要进行定义，而对于指针的定义，与一般变量一样。2、 存放地址不同一个变量的(内存)地址称为该变量的“指针”，通过指针能找到以它为地址的内存单元。而指针变量是用来存放另一个变量的地址的（即指针）。扩展资料：指针和指针变量的关系1、指针就是地址，地址就是指针。2、地址就是内存单元的编号。3、指针变量就是存放内存地址的变量。4、指针和指针变量是两个不同的概念，但要注意的是，通常我们叙述时会把指针变量简称为指针，实际他们含义并不一样。注：指针里存的是100. 指针：地址 - 具体。指针里存的是地址，指针：指针变量 -可变。指针的好处：1、直接访问硬件2、快速传递数据（指针表示地址）3、返回一个以上的值返回一个（数组或者结构体的指针）4、表示复杂的数据结构（结构体）5、方便处理字符串6、指针有助于理解面向对象

1. 定义指针变量的一般形式如下：类型名*指针变量名1，*指针变量名2，... *指针变量名n ;2. 空指针空指针是一个特殊的指针，它的值是0，C语言中用符号常量NULL（在stdio.h中定义）表示这个空值，并保证这个值不会是任何变量的地址。空指针对任何指针类型赋值都是合法的。一个指针变量具有空指针值表示当前它没有指向任何有意义的东西。3. void指针（void *）类型的指针叫通用指针，可以指向任何的变量，C语言允许直接把任何变量的地址作为指针赋给通用指针。但是有一点需要注意void*不能指向由const修饰的变量，eg const int test; void * ptv; ptv = &test;第三句是非法的，只有将ptv申明为const void * ptv;上述第三句(ptv = &test)，才是合法的.当需要使用通用指针所指的数据参加运算时，需要写出类型强制转换。如通用指针ptv 所指空间的数据是整型数据，p是整型指针，用此式转换：p=(int *)ptv ;

前者是变量，后者是常量，指针变量很显然这个指针指向的存储单元存储的数据是可以变化的和指针常量指向的数据是程序运行前定义的一个不会变化的量，在程序运行过程中， 这个量既不能改变大小，也不能改变类型。存放地址的变量称为指针变量。指针变量是一种特殊的变量，它不同于一般的变量，一般变量存放的是数据本身，而指针变量存放的是数据的地址。举例：int a = 68 ,系统为变量a分配的首地址为0X065FDF4H，声明空指针long *p = NULL，p=&a是存放变量a地址的指针变量，即p=&a中存放的值为0x065FDF4H（a的值为68，&a的值为0x065FDF4H）。对变量a的访问有两种方式：一是直接按地址0x065FDF4H找到a的存储单元，从而对变量a进行访问；二是按系统为p=&a分配的地址先找到p=&a，然后根据p，&a的值（即变量a地址0x065FDF4H）找到变量a在内存中的存储单元，从而对变量a进行访问。对于前一种访问方式称为直接访问方式，后一种访问方式称为间接访问方式。如果一个指针变量存放的是某个对象的地址，则称这个指针变量指向该对象。在C++程序设计中，指针变量只有确定了指向才有意义。参考资料百度百科.百度百科.百度百科：百度百科，百度百科

int*代表的是int型的指针。声明的变量就叫指针变量。存放地址的变量称为指针变量。指针变量是一种特殊的变量，不同于一般的变量，变量存放的是数据本身，而指针变量存放的是数据的地址。举例：int* a = 68 ,系统为变量a分配的首地址为0X065FDF4H，声明空指针long *p = NULL，p=&a是存放变量a地址的指针变量，即p=&a中存放的值为0x065FDF4H（a的值为68，&a的值为0x065FDF4H）。扩展资料对变量a的访问有两种方式：一是直接按地址0x065FDF4H找到a的存储单元，从而对变量a进行访问；二是按系统为p=&a分配的地址先找到p=&a，然后根据p，&a的值（即变量a地址0x065FDF4H）找到变量a在内存中的存储单元，从而对变量a进行访问。对于前一种访问方式称为直接访问方式，后一种访问方式称为间接访问方式。如果一个指针变量存放的是某个对象的地址，则称这个指针变量指向该对象。在C++程序设计中，指针变量只有确定了指向才有意义。参考资料来源：百度百科-指针变量

指针变量也是变量，只是它的值是地址，你所说的存放是什么意思？

*b=xxx就可以了

指针就是地址，地址就是指针；指针变量是一个变量，它保存了基本类型变量的地址。如果指针变量p保存了变量a的地址，那么称作p指向了a，*p 就是变量a。如果p是一个指针变量，*p 表示了以 p 的内容为地址的变量，就是p指向的变量。可以这样来理解指针：指针是一种特殊的语言机制，它存放的是其它变量的地址，并且可以通过解引用操作符*，来获取该地址的内容。这也造成了一种指向的关系。各变量的类型推导，foo_p是指针，且指向int，故foo_p的类型是int*，也就是在"*"前添加int；foo_pp也是指针，且指向foo_p，故foo_pp的类型是int**，也就是在"*"前添加int*。扩展资料指针变量的初始化：可以用赋值语句使一个指针变量得到另一个变量的地址，从而使它指向该变量。比如：int i, *j;j = &i;这样就将变量 i 的地址放到了指针变量 j 中，通过 i 的地址，j 就能找到 i 中的数据，所以 j 就“指向”了变量 i。其中 & 是“取地址运算符”，与 scanf 中的 & 是一样的概念；* 为“指针运算符”，功能是取其内部所存变量地址所指向变量中的内容。因为 j 是定义成指针型变量，所以 j 中只能存放变量的地址，所以变量i前一定要加 &。需要注意的是，指针变量中只能存放地址，不要将一个整数或任何其他非地址类型的数据赋给一个指针变量。此外，还有两点需要注意：1、j 不是 i，i 也不是 j。修改j的值不会影响i的值，修改 i 的值也不会影响 j 的值。j 是变量 i 的地址，而 i 是变量 i 里面的数据。一个是“内存单元的地址”，另一个是“内存单元的内容”。2、定义指针变量时的“*j”和程序中用到的“*j”含义不同。定义指针变量时的“*j”只是一个声明，此时的“*”仅表示该变量是一个指针变量，并没有其他含义。而且此时该指针变量并未指向任何一个变量，至于具体指向哪个变量要在程序中指定，即给指针变量初始化。而当指定 j 指向变量 i 之后，*j 就完全等同于 i 了，可以相互替换。

指针变量，顾名思义首先是一个变量，专门用来存放地址的。如果说指针和指针变量严格来说的话，指针就是地址的意思，但是一般我们习惯于将指针变量叫做指针。一个指针变量占4个字节的大小（32位机）。里面存放的就是一个其他变量的地址。通过这个地址就能访问响应的变量了

可以 语法没问题

指针变量的地址只能赋给指针变量。#include"stdio.h"intmain(){doublepi=3.1415926,*p,**q; p=u03c0 /*把double变量的地址赋给p*/ q=&p; /*把指针变量p的地址赋给q*/ printf("pi=%.7lf *p=%.7lf **q=%.7lf ",pi,*p,**q);/*检查赋值的效果 */ system("pause"); return0;}

就和变量和常量的区别是一样的指针变量 这个指针可以改变值指针常量 指针本身是不能改变的。 比如int a[10];//定义一个数组int *p=a;这个是指针变量。 可以重新赋值 p++, p=&a[5];这些都可以而int * const p=a;这个是指针常量 p值不能更改 只能指向a

C语言中有两种非常有用的运算符++和--，分别称为递增和递减运算符，对变量执行加1或减1操作，且运算结果仍赋给该变量。递增、递减运算符和负号一样都是单目运算符，统称单项算术运算符。指针变量本身储存的是物理地址。使用*运算符可以取得该物理地址对应的值。连续使用两个*，就可以操作指向指针的指针变量。例如：printf("%d",(*(*p1))++);printf("%d",++(*(*p2)));

定义方法：数据类型 *指针变量名;如定义一个指向int型变量的指针——int *p;则我们可以继续写如下代码——int a = 4;p = &a;printf("%d", *p);在这里，我们定义了一个变量a，我们把它理解为内存空间连续的4个字节（int型占用4字节），则这4个字节的空间保存着一个数4。&是取地址符号，即把变量a的地址（即这4个字节的首地址）赋给指针p（记住指针p的类型和变量a的类型要保持一致，否则的话，要进行类型转换）。这样子，指针p就保存着变量a的地址。我们如果把指针p当做内存空间里面另外一个连续的4个字节，那么这4个字节保存的数就是变量a的地址。printf("%d",*p)和printf("%d",a)的结果是一样的。这里的*是取变量符号（与&刚好作用相反，通过变量的地址找到变量），与定义时int *p的*号作用不同（定义时的*表示该变量是个指针变量，而非是取它指向的变量）。指针在C语言学习中是一个很重要的部分，在将来数据结构中也会大量用到，你可以多看看书上的例题来掌握它。推荐你翻阅谭浩强著的《C程序设计》第10章。希望我的回答对你有帮助，祝你好运。

指针变量坟地址百型变量和指针型变量，地址型的指度针指向变量后变量数值不便例：a=10,若把b指向a的地址变量，那麽内b也=10，指针型变量就是说，a已经占了这块内容存，所以就是a=10,b若指向a将不可能=10

指针定义类型是为了取值及指针运算。一、指针的本质为内存地址。不管什么类型的指针，其本质都是内存地址。二、定义指针类型，可以更方便的取值。不管定义什么指针，保存什么样的地址，其目的都不是为了获取到这个地址值，而是为了访问地址上的数据。定义了指针类型，就可以很方便的取得数据。如果指针p类型为long*型，那么当使用*p取值时，就是取p值这个地址上，连续4个字节的数据值。而如果p类型为char*型，那么使用*p就是在p这个地址上的一个字节数据。三、定义指针类型，方便指针运算。使用指针，最常用的操作除取值为，就是指针的移动，也就是加减运算。通过指针加减，可以很方便的访问相邻或者间接相邻的同类单元。同样的p+1,不同指针移动的实际内存字节数不同，其值为sizeof(指针指向类型)。即对于type*p;p+n的实际偏移地址值为sizeof(type)*n。

对；存放地址的变量称为指针变量。指针变量是一种特殊的变量，它不同于一般的变量，一般变量存放的是数据本身，而指针变量存放的是数据的地址；

以下每一行都可以定义一个指针变量的：char *p1;int *p2;float *p3;double *p4;char **p5;…………

您好，这样的：一、字符串指针变量的说明和使用字符串指针变量的定义说明与指向字符变量的指针变量说明是相同的。只能按对指针变量的赋值不同来区别。对指向字符变量的指针变量应赋予该字符变量的地址。如： char c,*p=&c;表示p是一个指向字符变量c的指针变量。而： char *s="C Language";则表示s是一个指向字符串的指针变量。把字符串的首地址赋予s。请看下面一例。main(){　　char *ps;　　ps="C Language";　　printf("%s",ps);　　}　　运行结果为：　　C Language　　上例中，首先定义ps是一个字符指针变量， 然后把字符串的首　　地址赋予ps(应写出整个字符串，以便编译系统把该串装入连续的一　　块内存单元)，并把首地址送入ps。程序中的： char *ps;　　ps="C Language";等效于： char *ps="C Language";　　输出字符串中n个字符后的所有字符。　　二、字符指针变量的运算　　main(){　　char *ps="this is a book";　　int n=10;　　ps=ps+n;　　printf("%s ",ps);　　}　　运行结果为：　　book　　在程序中对ps初始化时，即把字符串首地址赋予ps，当ps= ps　　+10之后，ps指向字符“b”，因此输出为"book"。　　main(){　　char st[20],*ps;　　int i;　　printf("input a string: ");　　ps=st;　　scanf("%s",ps);　　for(i=0;ps[i]!="";i++)　　if(ps[i]=="k"){　　printf("there is a "k" in the string ");　　break;　　}　　if(ps[i]=="") printf("There is no "k" in the string ");　　}本例是在输入的字符串中查找有无‘k"字符。三、字符串指针作为函数参数的使用。要求把一个 字符串的内容复制到另一个字符串中，并且不能使用strcpy函数。函　　数cprstr的形参为两个字符指针变量。pss指向源字符串，pds指向目标字符串。表达式： (*pds=*pss)!=`"　　cpystr(char *pss,char *pds){　　while((*pds=*pss)!=""){　　pds++;　　pss++; }　　}　　main(){　　char *pa="CHINA",b[10],*pb;　　pb=b;　　cpystr(pa,pb);　　printf("string a=%s string b=%s ",pa,pb);　　}在上例中，程序完成了两项工作：一是把pss指向的源字符复制到pds所指向的目标字符中，二是判断所复制的字符是否为`"，若是则表明源字符串结束，不再循环。否则，pds和pss都加1，指向下一字符。四、使用字符串指针变量与字符数组的区别用字符数组和字符指针变量都可实现字符串的存储和运算。 但两者是有区别的。在使用时应注意以下几个问题：1. 字符串指针变量本身是一个变量，用于存放字符串的首地址。而字符串本身是存放在以该首地址为首的一块连续的内存空间中并以‘"作为串的结束。字符数组是由于若干个数组元素组成的，它可用来存放整个字符串。2. 对字符数组作初始化赋值，必须采用外部类型或静态类型，如： static char st[]={“C Language”};而对字符串指针变量则无此限制，如： char *ps="C Language";3. 对字符串指针方式 char *ps="C Language";可以写为： char *ps;　　ps="C Language"; 而对数组方式： static char st[]={"C Language"};不能写为： char st[20]; st={"C Language"};而只能对字符数组的各元素逐个赋值。从以上几点可以看出字符串指针变量与字符数组在使用时的区别，同时也可看出使用指针变量更加方便。前面说过，当一个指针变量在未取得确定地址前使用是危险的，容易引起错误。但是对指针变量直接赋值是可以的。因为C系统对指针变量赋值时要给以确定的地址。因此， char *ps="C Langage";或者 char *ps; ps="C Language";都是合法的。

不可以。

B

int *p = &num 这句是声明，初始化的时候*就是一种类型。*p = 9;这句是赋值，和声明不一样的，*代表取到p的值，就是给p指向的值赋值。int *p = &num这种形式不好理解，你可以写成 int * p = &num这种形式。

变量的指针，其含义是指该变量的地址。C语言用变量来存储数据，用函数来定义一段可以重复使用的代码，它们最终都要放到内存中才能供 CPU 使用。数据和代码都以二进制的形式存储在内存中，计算机无法从格式上区分某块内存到底存储的是数据还是代码。当程序被加载到内存后，操作系统会给不同的内存块指定不同的权限，拥有读取和执行权限的内存块就是代码，而拥有读取和写入权限（也可能只有读取权限）的内存块就是数据。CPU 只能通过地址来取得内存中的代码和数据，程序在执行过程中会告知 CPU 要执行的代码以及要读写的数据的地址。扩展资料：在C语言中，允许用一个变量来存放指针，这种变量称为指针变量。指针变量的值就是某份数据的地址，这样的一份数据可以是数组、字符串、函数，也可以是另外的一个普通变量或指针变量。现在假设有一个 char 类型的变量 c，它存储了字符 "K"（ASCII码为十进制数 75），并占用了地址为 0X11A 的内存（地址通常用十六进制表示）。另外有一个指针变量 p，它的值为 0X11A，正好等于变量 c 的地址，这种情况我们就称 p 指向了 c，或者说 p 是指向变量 c 的指针。参考资料来源：百度百科-指针

指针变量的值的含义是：指针变量存放的是地址值。任何一个指针变量，无论是什么类型的指针变量，其占用内存空间的大小都是4个字节，即32位二进制。

int **p;char **p;等等都是一个指向指针的指针变量。。

可以的。 在pc上你设置一个指针等于2000跟设置它等于0实际上是一样的

指针变量是一个存地址的变量，赋值是只能传地址(跟int型只能赋值整型一样的)

变量指针：指向的数据为变量的指针，如char *p。与此相对的是常量指针，如const char* p。指针变量：类型为指针的变量，如char *p。与此相对的是指针常量，如char* const p。

指针就是保存对象地址的好牌。一级指针:比如你知道小明的家、在一栋楼里面的门牌号。你就可以直接找到这个门牌号，而找到小明了。别人也可以通过这个门牌号，找到小明。小明也可以通过这个门牌号，告诉别人自己家的位置。通过门牌号=找到小明(门牌号)二级指针:就比如物业的登记薄，登记薄里就有小明家，对应的门牌号。通过登记薄，找到门牌号=找到小明(登记薄，门牌号)

在C语言中：1.普通指针：*p指向一个值，本身存的是其地址；2.指向指针的指针：*（*p）指向一个值，这个值是个地址，所以也就是上面说的指针，指针的指针本身存的还是个地址；以下均是以上两种指针的变种：char*p，1变形，指向字符或指向字符串或指向一维字符数组的指针，指向的是字符的地址或一维数组的首元素；char（*p）[N]，行指针，2变形，指向的是二维数组的首地址，也就是上面所说的char*p；int(*p)()，函数指针，1变形，指向的是某函数，本身存的是该函数的入口地址其实就两类，区分时就看指针指向的是值还是指针

指针指向数组元素时，可以对指针进行以下运算： 加一个整数(用+或+=)， 减一个整数(用-或-=)，自加运算，如p++，++p自减运算，如p--，--p 两个指针相减，只有p1和p2都指向同一数组中的元素时才有意义)。

指针指向的是一个地址,但这个地址里面可能是一个变量,也可以是个常量,或者是其它类型...

要想学好C,C++，必须学好指针。。

指针变量，顾名思义首先是一个变量，专门用来存放地址的。如果说指针和指针变量严格来说的话，指针就是地址的意思，但是一般我们习惯于将指针变量叫做指针。一个指针变量占4个字节的大小（32位机）。里面存放的就是一个其他变量的地址。通过这个地址就能访问响应的变量了

指针是C语言的精华部分，通过利用指针，我们能很好地利用内存资源，使其发挥最大的效率。有了指针技术，我们可以描述复杂的数据结构，对字符串的处理可以更灵活，对数组的处理更方便，使程序的书写简洁，高效，清爽。但由于指针对初学者来说，难于理解和掌握，需要一定的计算机硬件的知识做基础，这就需要多做多练，多上机动手，才能在实践中尽快掌握，成为C的高手。过去，我们在编程中定义或说明变量，编译系统就为已定义的变量分配相应的内存单元，也就是说，每个变量在内存会有固定的位置，有具体的地址。由于变量的数据类型不同，它所占的内存单元数也不相同。若我们在程序中做定义为：int a=1,b=2;float x=3.4, y = 4 . 5 ;double m=3.124;char ch1="a", ch2="b";让我们先看一下编译系统是怎样为变量分配内存的。变量a,b是整型变量，在内存各占2个字节；x,y是实型，各占4个字节；m是双精度实型，占8个字节；ch1,ch2是字符型，各占1个字节。由于计算机内存是按字节编址的，设变量的存放从内存2000单元开始存放，则编译系统对变量在内存的安放情况为图6-1所示。变量在内存中按照数据类型的不同，占内存的大小也不同，都有具体的内存单元地址，如变量a在内存的地址是2000，占据两个字节后，变量b的内存地址就为2002，变量m的内存地址为2012等。对内存中变量的访问，过去用scanf("%d%d%f",&a,&b,&x)表示将数据输入变量的地址所指示的内存单元。那么，访问变量，首先应找到其在内存的地址，或者说，一个地址唯一指向一个内存变量，我们称这个地址为变量的指针。如果将变量的地址保存在内存的特定区域，用变量来存放这些地址，这样的变量就是指针变量，通过指针对所指向变量的访问，也就是一种对变量的“间接访问”。设一组指针变量pa、pb、px、py、pm、pch1、pch2，分别指向上述的变量a、b、x、y、m、ch1、ch2，指针变量也同样被存放在内存，二者的关系如图6-2所示：在图6-2中，左部所示的内存存放了指针变量的值，该值给出的是所指变量的地址，通过该地址，就可以对右部描述的变量进行访问。如指针变量pa的值为2000，是变量a在内存的地址。因此，pa就指向变量a。变量的地址就是指针，存放指针的变量就是指针变量。

这是指针与数组可以互换的关系了，比如int buf[10]; int *ptr = buf; 所以*ptr = buf[0]; *(ptr+1) = buf[1];也可以表示ptr[0] = buf[0]; ptr[1] = buf[1];所以说在scanf函数里，传入的是一个地址，而ptr[i]明显是这个地址的值，所以要加个取地址符&。

语言中，指针是一种类型，被称为“指针类型”。指针类型描述的是一个地址，这个地址指向内存中另外一个对象的位置。简单地说，指针表示的是它所指向对象的地址。1、比较point,*point,&point三者的区别对于int*point；point：是指针变量，其内容是地址量。*point：是指针变量的目标变量，即指针指向的那个变量，其内容是数据。&point：是指指针变量本身所占据的存储地址。2、指针与数组用指针和数组名在访问内存中的数据时，他们的表现形式是等价的，因为他们都是地址量。数组名表示整个数组的首地址，可以看作是固定地址的指针，不能被赋值。数组名无须赋初值，而指针在使用前必须赋初值。3、字符指针和字符串字符串是一个字符数组，字符串以‘"结束。printf函数的%s格式输出字符时，是从给定的地址开始，到遇上第一个‘"字符时结束。对字符指针初始化，是将字符串的首地址赋给指针。4、指针型函数所谓指针型函数，即返回值是指针（地址）的函数。5、多级指针指向指针的指针（**p）就是二级指针，指向指针的指针的指针（***p）是3级指针。多级指针类似于间接寻址。6、指向函数的指针C语言中的函数名表示函数的首地址，即函数执行的人口地址。定义形式：[存储类型][数据类型标示符](*指向函数的指针变量名)()；例子：int(*fun)();//指向函数的指针，int*fun()；//指针型函数，注意（*fun）括号不能少7、动态指针当需要一大片内存的时候，最好使用动态分配。使用malloc函数：void*malloc(size_tsize)。例子：int*pn=malloc(10*sizeof(int));double*pd=malloc(10*sizeof(double));

根据你的定义，使用LinkList定义的变量是指针变量，而加上*即LinkList *C表示的是指向指针的指针，表示二级指针变量。你的合并函数是一个没有返回值的函数，所以你在函数体内更改C要达到更改实参的效果，你必须传入实参的地址。如果是一级指针，C接收实参指向的对象地址，如果此时在函数体内对C进行赋值，只是改变了函数体内C的指向，实参还是指向原来的地址。函数内是改变不了实参C本身的指向，只有传入实参C变量本身的地址，那么形参就要定义指向指针的变量来接收实参。以上是一种方法，另外一种方法就是通过函数返回值，返回新合并的链表的头。那函数类型就可以改为：LinkList MergeList(LinkList a, LinkList b)。这可以多练习好好理解一下。

指针是地址,指针变量就是针对存放地址的变量;

指针变量是地址

指针是C语言的精华部分，通过利用指针，我们能很好地利用内存资源，使其发挥最大的效率。有了指针技术，我们可以描述复杂的数据结构，对字符串的处理可以更灵活，对数组的处理更方便，使程序的书写简洁，高效，清爽。但由于指针对初学者来说，难于理解和掌握，需要一定的计算机硬件的知识做基础，这就需要多做多练，多上机动手，才能在实践中尽快掌握，成为C的高手。过去，我们在编程中定义或说明变量，编译系统就为已定义的变量分配相应的内存单元，也就是说，每个变量在内存会有固定的位置，有具体的地址。由于变量的数据类型不同，它所占的内存单元数也不相同。若我们在程序中做定义为：int a=1,b=2;float x=3.4, y = 4 . 5 ;double m=3.124;char ch1="a", ch2="b";让我们先看一下编译系统是怎样为变量分配内存的。变量a,b是整型变量，在内存各占2个字节；x,y是实型，各占4个字节；m是双精度实型，占8个字节；ch1,ch2是字符型，各占1个字节。由于计算机内存是按字节编址的，设变量的存放从内存2000单元开始存放，则编译系统对变量在内存的安放情况为图6-1所示。变量在内存中按照数据类型的不同，占内存的大小也不同，都有具体的内存单元地址，如变量a在内存的地址是2000，占据两个字节后，变量b的内存地址就为2002，变量m的内存地址为2012等。对内存中变量的访问，过去用scanf("%d%d%f",&a,&b,&x)表示将数据输入变量的地址所指示的内存单元。那么，访问变量，首先应找到其在内存的地址，或者说，一个地址唯一指向一个内存变量，我们称这个地址为变量的指针。如果将变量的地址保存在内存的特定区域，用变量来存放这些地址，这样的变量就是指针变量，通过指针对所指向变量的访问，也就是一种对变量的“间接访问”。设一组指针变量pa、pb、px、py、pm、pch1、pch2，分别指向上述的变量a、b、x、y、m、ch1、ch2，指针变量也同样被存放在内存，二者的关系如图6-2所示：在图6-2中，左部所示的内存存放了指针变量的值，该值给出的是所指变量的地址，通过该地址，就可以对右部描述的变量进行访问。如指针变量pa的值为2000，是变量a在内存的地址。因此，pa就指向变量a。变量的地址就是指针，存放指针的变量就是指针变量。

局部变量也称为内部变量。局部变量是在函数内作定义说明的。其作用域仅限于函数内， 离开该函数后再使用这种变量是非法的。 例如： int f1(int a) /*函数f1*/ { int b,c; …… } a,b,c有效 int f2(int x) /*函数f2*/ { int y,z; …… } x,y,z有效 main() { int m,n; …… } m,n有效 在函数f1内定义了三个变量，a为形参，b,c为一般变量。在 f1的范围内a,b,c有效，或者说a,b,c变量的作用域限于f1内。同理，x,y,z的作用域限于f2内。m,n的作用域限于main函数内。关于局部变量的作用域还要说明以下几点： 1) 主函数中定义的变量也只能在主函数中使用，不能在其它函数中使用。同时，主函数中也不能使用其它函数中定义的变量。因为主函数也是一个函数，它与其它函数是平行关系。这一点是与其它语言不同的，应予以注意。 2) 形参变量是属于被调函数的局部变量，实参变量是属于主调函数的局部变量。 3) 允许在不同的函数中使用相同的变量名，它们代表不同的对象，分配不同的单元，互不干扰，也不会发生混淆。如在前例中，形参和实参的变量名都为n，是完全允许的。

0xcccccccc

直接修改就可以了。比如你的成员变量为String a=“yes” ； 然后在内部类里直接修改为 a = “no”；

你是不是定义全局生命周期的变量？static int n;n在程序的整个生命周期有效

函数内部定义的auto变量(定义变量默认为auto),在栈中开辟内存(系统自动开辟内存).函数执行完毕释放.用malloc函数分配的空间属于堆栈区,不自动释放,必需由程序员自己释放或者程序结束回收`

局部变量从名字上看就是在某个函数范围内定义的，所以称为局部，他的生命期为从定义时起，到这个函数结束

系统环境变量的影响范围很广,凡是在一个 JVM下运行的线程都受其影响. Kettle 变量限制了变量的作用范围, 变量范围包括三种分别是 grand-parent job, parent job, root job 内部变量: 是 kettle 内置的一些变量, 主要是kettle 运行时依赖的环境, 如转换文件名称, 转换路径,ip地址, kettle 版本号等等. "Kettle 变量" 只能通过设置环境变量 (Set Variable) 步骤设置,同时设置变量的作用范围. "内部变量" 是预置的无须设置. 命令行参数: 图形界面下,每次运行时有要求输入参数的提示窗口.

应该是，过程变量（也就是外部变量），内部变量，和系统变量。和400的PLC建立连接，需要在过程变量里建立变量

@@。全局变量是编程术语中的一种，源自于变量之分，引用时必须以@@开头。变量分为局部与全局，局部变量又可称之为内部变量。由某对象或某个函数所创建的变量通常都是局部变量，只能被内部引用，而无法被其它对象或函数引用。

直接用就行，只要不和局部变量同名就行~

wincc的数据库是微软为西门子单独开发的，他的数据是加了密的，所以只能在wincc相应的表里看对于WinCC来说，变量是数据的载体，借助于变量，数据可以传递到WinCC中。一个变量包含了数据的地址和符号名。地址用于与自动化系统（PLC）通讯；符号名是项目/应用中的唯一识别。WinCC的变量一般分为内部变量、外部变量、WinCC系统变量、S7系统变量、系统信息变量和脚本变量。除了"脚本变量"外，所有的变量的创建和维护工作都在"变量管理器"下进行。一、内部变量WinCC内部使用的变量，与外部过程无关，无需建立过程驱动程序、通道单元和通道连接。使用数量不受限制。二、外部变量外部变量由外部过程为其提供数值，因此也叫做"过程变量"。外部变量是基于"驱动程序-通道单元-连接"的，其与自动化系统中的数据是相对应。创建外部变量时，首先要明确其所属的通讯链路关系：驱动程序 - 通道单元 - 连接。在相应的连接下（如图2中的NewConnection1）创建变量并为其指定PLC侧的地址，该地址可以是输入/输出过程映象区、位存储区以及DB块。外部变量的使用数量由PowerTags授权决定。如图3所示，在WinCC的项目管理器下，给出了当前已定义的外部变量的个数和总授权数，外部变量的个数不能超出总授权数。需要注意的是，不管外部变量定义为何种数据类型：BOOL、32位浮点数等，它们都各自占用一个授权。三、WinCC系统变量WinCC系统提供的预先定义好的变量。每个系统变量均有明确意义，可提供现场功能。系统变量由WinCC系统创建，工程人员不能创建，但可以使用。系统变量是一种特殊的内部变量，以"@"开头。四、S7系统变量基于TIA方式创建的项目，在编译完成OS站后，STEP7会向WinCC传递S7系统变量，包括PLC变量，归档和报警等。这些变量称其为"S7系统变量"。S7系统变量默认以"S7$Program（连接名）"开头。只有采用TIA方式创建的项目才有S7系统变量，这部分内容集中在后面的TIA中再详细讨论。五、系统信息变量在"驱动程序"中有一种特殊的"驱动"——WinCC系统信息通道。在WinCC的系统信息通道下，可建立专门记录系统信息的变量，例如可记录WinCC系统的当前时间、CPU占用率、磁盘容量等信息。要使用系统信息变量，首先要添加"系统信息通道"，然后在其下建立连接，在"连接"下就可以创建系统信息变量了。方法和添加"S7协议集"类似，如图5所示。系统信息变量不占用PowerTag授权。六、脚本变量在脚本中定义和使用的变量，只能在其定义范围内使用，遵循C/VB语言规范。它与编程语言相关，不在变量管理器中维护。

全局变量是编程术语中的一种，源自于变量之分。x0dx0a变量分为局部与全局，局部变量又可称之为内部变量。由某对象或某个函数所创建的变量通常都是局部变量，只能被内部引用，而无法被其它对象或函数引用。x0dx0a全局变量既可以是某对象函数创建，也可以是在本程序任何地方创建。全局变量是可以被本程序所有对象或函数引用。一个局部变量在被其它对象引用时，会是一个空值。但全局变量却不会出现这种情况。x0dx0a x0dx0a全局变量全部存放在静态存储区，在程序开始执行时给全局变量分配存储区，程序行完毕就释放。在程序执行过程中它们占据固定的存储单元，而不动态地进行分配和释放；

静态局部变量的生存周期虽然延续到整个程序执行完毕，但其作用域仍与自动变量相同，即只能在定义该变量的函数或语句块内使用。退出该函数或语句后，尽管该变量还存在，但其他的程序代码不能使用它，这是静态局部变与全局即外部不同之处。

内部静态类变量的作用域和寿命与自动类变量的相同是错误的。Java语言允许在类中再定义类，这种在其它类内部定义的类就叫内部类。内部类又分为：常规内部类、局部内部类、匿名内部类和静态嵌套类四种。静态内部类定义在类中，任何方法外，用static定义。静态内部类只能访问外部类的静态成员。生成（new）一个静态内部类不需要外部类成员：这是静态内部类和成员内部类的区别。静态内部类的对象可以直接生成：Outer.Innerin=newOuter.Inner()；而不需要通过生成外部类对象来生成。这样实际上使静态内部类成为了一个顶级类。可以定义私有静态内部类。

你用3个数据去做，a是1到10 b是10-a ， c前10秒等于a 后十秒等于b 那么C就是满足你所需要的数据

mcgs变量，隶属于mcgs数据库，其可以为内部变量，也可以为外部变量，无论是什么类型变量，都将计数在点数范畴。而plc变量，隶属于plc中，因为引入了iec61131-3标准后，在iec标准内，为了实现跨plc型号的使用，因此引入了标签编程而不是绝对地址编程，因此，才有了plc变量这个概念，实际上，plc变量就是指为plc定义的标签变量。

Fortran 语言里没有全局变量这个叫法。一些老的教科书习惯把 common 里的变量，称为全局变量。其实是不对的，应该叫“未命名的common 数据”。module 中定义的变量，可以在 use 了该module 的程序单元里通用，并共享同一个内存空间。前提是该变量有 public 和 save 属性。（如果没有指定save，则默认具有save属性。如果没有指定 private，则默认具有 public 属性）而 module 中的子程序，其内部的变量，与常规的子程序的内部变量一样，其值在该子程序范围内有效。退出该子程序后，其地址和值就变为不确定。除非你指定了它具有 save 属性。子程序中具有 save 属性的变量，在下次进入子程序时，保留上一次的值。但也不能在子程序之外直接使用它。

额。。。。你的问题在于定义内部变量，却没有使用I/O之类的去读它，所以导致该变量值为空。解决办法有二：1、添加一个I/O域读一下，这样他的初始值就为0了2、定义变量的时候为其指定初始值

这个全局变量有两种：一种是适用于当前窗体，即只在当前窗体中使用，这种比较简单，将变量定义在方法外class之内即可，一般都写在所有方法的前面，方便查看。另一种是定义多个界面的的变量，一般会新建一个类，如CommonData.cs之类的，然后在里面写全局变量，变量形式如：调用方法如下

估计我没分，函数的他说了，然后是数组，array_push($array,$value)

函数内的static变量存储在静态内存里。

测试了下，结果如下：例如你需要监控的变量为m2000.0,取反后的变量为m2001.0（也可以是内部变量），你需要按下面步骤操作：1.建立3个变量m2000.0,m2001.0,mb2000(地址和名字一样）见图1（建议把变量的周期时间选最小，这样即时性更好）2.编写一个脚本如图23.最后在mb2000的属性-变更数值中添加脚本，如图3。（测试发现只能对字节以上的变量，变更数值才起作用，bool变量没反应）完成上面3个步骤，每当m2000.0变化时，m2001.0会随之取反。图片说明：1，12，33，2

不使用var定义的默认为全局