指针的定义,初步应用

1，变量a本质上代表一个储存单元。Cpu通过该储存单元的地址访问储存单元中的数据。

变量a本来就代表两个意思：存储单元的地址和存储单元中的数据。为了消除这种二义性，C语言规定a表示存储单元中的数据，&a表示存储单元的地址。A存储单元中的数据可以是一个普通数值，也可以是另一个存储单元的地址。比如a=&b就是将b的存储单元的地址存入a存储单元中。C语言规定*a代表a的存储单元的地址对应的存储单元的数据，也就是访问了*a就是访问b，于是*a提供了通过a访问b中的数据的手段。2，利用变量名，直接对变量进行操作叫直接访问，

3，将a+b的和送到被这个指针变量所指变量的那个空间中。我们已经知道了这个变量指向变量c,所以变量c的值就是a和b之和。

通过另一个变量的值来访问该变量的值称为间接访问。

变量的地址称为变量的指针。

C语言规定所有变量都要先说明再使用。

4，int* p int代表指针变量所指的类型。该指针变量只能指向整形变量。只能用表示地址的数据为指针初始化或赋值。（例如数组名，&变量名）。数组名代表了数组元素的起始地址。

还有一点就是相同类型的指针变量可以相互赋值。表示两个指针指向了同一个变量。

*px就是声明的时候指示px是一个指针。在定义处和下边*px代表的意思不一样。Px=3和*px=3.

不加星号就是把变量对应的地址改变了，加星号就是改变地址所对应的存储空间的内容了,也就是改变了指针指向变量的值。

4，一个指针只要被定义了，被赋值了，指针就可以用来引用被他所指的变量。

指针数组int *p3, int(*p)[3]

5,注意指针的概念辨析。

指针的值，就是指针所指的那块内存区域。

普通变量做函数的参数无法通过调用函数来完成数据的交换。

在被调用函数中形参也是指针。

这个图中指针的指向没有变化，但是指向的内容（值）变了。虽然调用完后地址被释放，但是内容没有被释放（找了个替死鬼。。。）。也就是说把实参的值给换了。

在非定义的部分出现*p。对指针做间接访问就意味着获得了指针所指变量的值。

实参指针，形参指针获得了同样的变量的地址，也就指向了相同的变量。

一旦指针被赋值了，我们对这个变量的引用被称为对变量的直接访问。

实际参数就是这个数是实际存在的。形式参数这个参数是没有的

C语言符号意义

C语言符号意义 Company Document number：WTUT-WT88Y-W8BBGB-BWYTT-19998

C语言符号意义大全 32个关键字及其含义： auto ：声明自动变量一般不使用 double ：声明双精度变量或函数 int：声明整型变量或函数 struct：声明结构体变量或函数 break：跳出当前循环 else ：条件语句否定分支（与 if 连用） long ：声明长整型变量或函数 switch :用于开关语句 case：开关语句分支 enum ：声明枚举类型 register：声明积存器变量 typedef：用以给数据类型取别名（当然还有其他作用） char ：声明字符型变量或函数 extern：声明变量是在其他文件正声明（也可以看做是引用变量）return ：子程序返回语句（可以带参数，也看不带参数）union：声明联合数据类型 const ：声明只读变量 float：声明浮点型变量或函数 short ：声明短整型变量或函数 unsigned：声明无符号类型变量或函数

continue：结束当前循环，开始下一轮循环 for：一种循环语句(可意会不可言传） signed：生命有符号类型变量或函数 void ：声明函数无返回值或无参数，声明无类型指针（基本上就这三个作用） default：开关语句中的“其他”分支 goto：无条件跳转语句 sizeof：计算数据类型长度 volatile：说明变量在程序执行中可被隐含地改变 do ：循环语句的循环体 while ：循环语句的循环条件 static ：声明静态变量 if：条件语句 C语言中像%D&%f符号的作用说一下 C语言中的符号运算符的种类C语言的运算符可分为以下几类：1.算术运算符用于各类数值运算。包括加(+)、减(-)、乘(*)、除(/)、求余(或称模运算，%)、自增(++)、自减(–)共七种。 2.关系运算符用于比较运算。包括大于(>)、小于(<)、等于(==)、大于等于(>=)、小于等于(<=)和不等于(!=)六种。 3.逻辑运算符用于逻辑运算。包括与(&&)、或(||)、非(!)三种。 4.位操作运算符参与运算的量，按二进制位进行运算。包括位与(&)、位或(|)、位非(~)、位异或(^)、左移(<<)、右移(>>)六种。

指针与引用的区别(非常经典)

c++中，引用和指针的区别 (1)引用总是指向一个对象,没有所谓的null reference .所有当有可能指向一个对象也由可能不指向对象则必须使用指针. 由于C++ 要求reference 总是指向一个对象所以reference要求有初值. String & rs = string1; 由于没有所谓的null reference 所以所以在使用前不需要进行测试其是否有值.,而使用指针则需要测试其的有效性. (2)指针可以被重新赋值而reference则总是指向最初或地的对象. (3)必须使用reference的场合. Operator[] 操作符由于该操作符很特别地必须返回[能够被当做assignment 赋值对象] 的东西,所以需要给他返回一个reference. (4)其实引用在函数的参数中使用很经常. void Get***(const int& a) //这样使用了引用有可以保证不修改被引用的值 { } 引用和指针 ★相同点： 1. 都是地址的概念；指针指向一块内存，它的内容是所指内存的地址；引用是某块内存的别名。 ★区别： 1. 指针是一个实体，而引用仅是个别名； 2. 引用使用时无需解引用(*)，指针需要解引用； 3. 引用只能在定义时被初始化一次，之后不可变；指针可变；引用“从一而终” ^_^ 4. 引用没有const，指针有const，const 的指针不可变； 5. 引用不能为空，指针可以为空； 6. “sizeof 引用”得到的是所指向的变量(对象)的大小，而“sizeof 指针”得到的是指针本身(所指向的变量或对象的地址)的大小； typeid(T) == typeid(T&) 恒为真，sizeof(T) == sizeof(T&) 恒为真，但是当引用作为成员时，其占用空间与指针相同（没找到标准的规定）。

c++复杂类型指针变量的声明

曾经碰到过让你迷惑不解、类似于int * (* (*fp1) (int) ) [10];这样的变量声明吗？本文将由易到难，一步一步教会你如何理解这种复杂的C/C++声明。我们将从每天都能碰到的较简单的声明入手，然后逐步加入const修饰符和typedef，还有函数指针，最后介绍一个能够让你准确地理解任何C/C++声明的“右左法则”。需要强调一下的是，复杂的C/C++声明并不是好的编程风格；我这里仅仅是教你如何去理解这些声明。注意：为了保证能够在同一行上显示代码和相关注释，本文最好在至少1024x768分辨率的显示器上阅读。让我们从一个非常简单的例子开始，如下：这个应该被理解为“declare n as an int”（n是一个int型的变量）。接下去来看一下指针变量，如下：这个应该被理解为“declare p as an int *”（p是一个int *型的变量），或者说p是一个指向一个int型变量的指针。我想在这里展开讨论一下：我觉得在声明一个指针（或引用）类型的变量时，最好将*（或&）写在紧靠变量之前，而不是紧跟基本类型之后。这样可以避免一些理解上的误区，比如：再来看一个指针的指针的例子：理论上，对于指针的级数没有限制，你可以定义一个浮点类型变量的指针的指针的指针的指针，再来看如下的声明：这里，p被声明为一个包含5个元素（int类型的指针）的数组。另外，我们还可以在同一个声明中混合实用*和&，如下：

注：p1是一个int类型的指针的指针；p2是一个int类型的指针的引用；p3是一个int类型引用的指针（不合法！）；p4是一个int类型引用的引用（不合法！）。 const修饰符当你想阻止一个变量被改变，可能会用到const关键字。在你给一个变量加上const修饰符的同时，通常需要对它进行初始化，因为以后的任何时候你将没有机会再去改变它。例如：上述两个变量n和m其实是同一种类型的——都是const int（整形恒量）。因为C++标准规定，const关键字放在类型或变量名之前等价的。我个人更喜欢第一种声明方式，因为它更突出了const修饰符的作用。当const与指针一起使用时，容易让人感到迷惑。例如，我们来看一下下面的p和q的声明：他们当中哪一个代表const int类型的指针（const直接修饰int），哪一个代表int类型的const指针（const直接修饰指针）？实际上，p和q都被声明为const int类型的指针。而int类型的const指针应该这样声明：这里，p和q都是指向const int类型的指针，也就是说，你在以后的程序里不能改变*p的值。而r是一个const指针，它在声明的时候被初始化指向变量n （即r=&n;）之后，r的值将不再允许被改变（但*r的值可以改变）。

C语言字符串指针问题

C语言字符串指针问题在C语言中，可以用两种方法访问一个字符串。用字符数组存放一个字符串，然后输出该字符串。 1.main(){ 2.char string[]=”I love China!”; 3.printf("%s\n",string); 4.} 说明：和前面介绍的数组属性一样，string是数组名，它代表字符数组的首地址。用字符串指针指向一个字符串。 1.main(){ 2.char *string=”I love China!”;

3.printf("%s\n",string); 4.} 字符串指针变量的定义说明与指向字符变量的指针变量说明是相同的。只能按对指针变量的赋值不同来区别。对指向字符变量的指针变量应赋予该字符变量的地址。如： char c,*p=&c; 表示p是一个指向字符变量c的指针变量。而： char *s="C Language"; 则表示s是一个指向字符串的指针变量。把字符串的首地址赋予s。上例中，首先定义string是一个字符指针变量，然后把字符串的首地址赋予string（应写出整个字符串，以便编译系统把该串装入连续的一块内存单元），并把首地址送入string。程序中的：char *ps="C Language"; 等效于： char *ps; ps="C Language"; 输出字符串中n个字符后的所有字符。 1.main(){ 2.char *ps="this is a book";

3.int n=10; 4.ps=ps+n; 5.printf("%s\n",ps); 6.} 运行结果为： book 在程序中对ps初始化时，即把字符串首地址赋予ps，当ps= ps+10之后，ps指向字符“b”，因此输出为"book"。在输入的字符串中查找有无‘k’字符。 1.main(){ 2.char st[20],*ps; 3.int i; 4.printf("input a string:\n"); 5.ps=st; 6.scanf("%s",ps); 7.for(i=0;ps[i]!='\0';i++) 8.if(ps[i]=='k'){ 9.printf("there is a 'k' in the string\n"); 10.break; 11.} 12.if(ps[i]=='\0') printf("There is no 'k' in the string\n");

指针的定义与初始化

int a; float b; a=3; b=5; 3AB0 a 3AB8 b 35

?变量与地址程序中: int i; float k; 内存中每个字节有一个编号-----地址…... …... 2000200120022005 内存 2003 i k 编译或函数调用时为其分配内存单元变量是对程序中数据存储空间的抽象

…... …... 2000 20042006 2005整型变量i 10 变量i _pointer 2001 20022003?指针：一个变量的地址 ?指针变量：专门存放变量地址的变量叫~ 2000 指针指针变量变量的内容变量的地址指针变量变量变量地址(指针) 变量值指向地址存入指针变量

指针变量与其所指向的变量之间的关系 ? 一般形式：[存储类型] 数据类型*指针名；变量i*i_pointer 3 i 2000 i_pointer *i_pointer &i i_pointer i=3;*i_pointer=3 合法标识符指针变量本身的存储类型指针的目标变量的数据类型表示定义指针变量不是‘*’运算符例int*p1,*p2; float *q ; static char *name; 注意： 1、int *p1, *p2;与int *p1, p2; 2、指针变量名是p1,p2 ,不是*p1,*p2 3、指针变量只能指向定义时所规定类型的变量 4、指针变量定义后，变量值不确定，应用前必须先赋值指针的定义

?指针是一种变量，在定义的同时可以赋给它初始值，称为指针的初始化。 ?形式如下：类型标识符*指针名=初始地址值；例如， int m，n[8]；char c; int *pm = &m；int *pn = n；char *pc = &c；变量地址作初值时，该变量在此之前已说明过，且类型应一致。可用已赋初值的指针去初始化其他指针变量.

如何透彻理解C语言中指针的概念

如何透彻理解C语言中指针的概念强大的指针功能是C语言区别于众多高级语言的一个重要特征。C语言指针的功能强大，使用灵活多变，可以有效地表示复杂的数据结构、动态分配内存、高效地使用数组和字符串、使得调用函数时得到多个返回值。而它的应用远不限于此。初学者对于指针的概念总是感到无所适从，有时觉得“自己懂了，为什么编译器就是不懂呢”，常有茫然和无助的感觉。学好指针的关键在于深入了解内存地址的空间可以理解为一个一维线性空间，内存的编址和寻址方法，以及指针在使用上的一些规定。事实上，指针就是方便我们对内存地址直接进行操作的，是为程序员服务的，我们只要抓住指针想要帮助我们解决什么问题这个核心，就可以轻松地理解它的工作原理。什么是指针，指针有什么作用指针就是指向一个特定内存地址的一个变量。简化了的内存空间模型是按照从0到某一个数（比如1048575=1M-1）的一维线性空间，其中的每一个数对应一个存储单元，即1个字节。指针有两个属性：指向性和偏移性。指向性指的是指针一定要有一个确定的指向，偏移性则是体现指针重要应用的方面，即指针可以按程序员的要求向前或向后偏移。指针的应用往往与数组联系在一起，为了方便说明问题，不妨从数组开始解释指针的偏移。数组就是许多的变量，它的一个重要特征就是在内存空间中连续地存放，而且是按下标顺序存放。比如我们定义一个有100个变量的一维整型数组，它一定从内存的某一个存储单元开始按数组下标顺序存放，连续占用100*4=400字节。当我们定义一个数组时，系统就会自动为它分配一个指针，这个指针指向数组的首地址。（在本文剩余部分的论述中，不加区分地使用“指向数组的首地址”与“指向数组的第一个元素”这两种说法，事实上这两种说法也是一致的。）为了让系统了解每一次指针偏移的单位，也为了方便程序员进行指针偏移（让程序员记住一个整形变量占用4字节，一个字符型变量占用1字节……等等是很麻烦的），不用每次去计算要偏移多少个字节，C语言引入了指针的基类型的概念。基类型的作用就是让系统了解某个指针每次偏移的字节数。比如，对于一个字符型指针，它每次偏移（比如ptr=ptr+1）所起到的作用就是让指针偏移1字节；而对于一个整型指针，它每次偏移就应该是4字节。这样操作数组时就带来了方便。比如对于一个指向某个整型数组起始存储单元（称为首地址）的指针ptr，ptr=ptr+1就表示将该指针指向这个数组的下一个元素的存储单元，即向后移动4字节，而不仅仅是移动一个存储单元（即移动1字节）。 &()、*()、和[ ]运算符的意义在本文中，将&()、*()和[ ]都看成是运算符。这样可以方便理解这三个概念。简单地说，&()将某个标识符（比如变量）转化为其在内存空间中的地址，而*()是产生一个对应于某个地址的标识符，[ ]就更复杂一点，ptr[i]表示

C语言指针知识点总结

指针 ★指针的重要性表示一些复杂的数据结构快速传递数据使函数返回一个以上的值能直接访问硬件能方便处理字符串是理解面向对象语言中引用的基础总结：指针是C 语言的灵魂 ★指针的定义 ☆地址内存单元的编号从零开始的非负整数范围：4G ☆指针 1.指针就是地址，地址就是指针 2.指针变量是存放地址的变量 3.指针和指针变量是两个不同的概念 4.叙述时通常把指针变量简称为指针，实际它们含义不一样 5.指针的本质就是一个操作受限的非负整数 ★指针的分类 ☆基本类型指针（重要） #include<> int main(void) { int *p; 果一个指针变量指向了某个普通变量，则*指针变量完全等同于普通变量例：若p 指向i ，则*p=i (*p 和i 可互相替换) p=&ch;法 2.定义指针变量 Int*p; 针运算符该运算符放在已经定义好的指针变量的前面如果p 是一个已经定义好的指针变量则*p 表示以p 的内容为地址的变量 ?如何通过被调函数修改主调函数普通变量的值 1.实参必须为该普通变量的地址 &... 2.形参必须为指针变量 *... 3.在被调函数中通过 *形参名=...... 的方式就可以修改主调函数相关变量的值例子：经典指针程序：互换数值形参和实参是不同的变量，修改形参不会改变实参 ?指针常见错误 #include<> #include<> void huhuan （int a, int b ） { int t; t=a; a=b; b=t; #include<> void huhuan2（int *p, int *q ） { int *t;//如果要互换p 和q 的值，则t 必须是int*，不能是int t=p; p=q; #include<> void huhuan3（int *p, int*q ） //形参的名字是p 和q ，接收实参数据的是p 和q ，而不是*p 和*q { int t;//如果要互换*p 和*q 的值，则t 必须是int ，不能是int* t=*p;//p 是int*，*p 是int Int f(int i,int j) { return 100; // return 88;error } Int main (void) { Int a=3,b=5; a=f(a,b); b=f(a,b); } 只能返回一个值 # include <> Void g(int*p,int*q) { *p=1; *q=2; } Int main(void) { Int a=3,b=5; g(&a,&b); Printf(“%d%d\n ”,a,b); Return 0; } 指针使函数返回一个以上的值

指向指针的指针——彻底搞定C指针

彻底搞定C指针---指向指针的指针彻底搞定C指针---指向指针的指针一．回顾指针概念：今天我们又要学习一个叫做指向另一指针地址的指针。让我们先回顾一下指针的概念吧！当我们程序如下申明变量： short int i; char a; short int * pi; 程序会在内存某地址空间上为各变量开辟空间，如下图所示。内存地址→6 7 8 9 10 11 12 13 14 15 ------------------------------------------------------------------------------------- … | | | | | | | | | | ------------------------------------------------------------------------------------- |short int i |char a| |short int * pi| 图中所示中可看出： i 变量在内存地址5的位置，占两个字节。 a变量在内存地址7的位置，占一个字节。 pi变量在内存地址9的位置，占两个字节。(注：pi 是指针，我这里指针的宽度只有两个字节，32位系统是四个字节) 接下来如下赋值: i=50; pi=&i; 经过上在两句的赋值，变量的内存映象如下: 内存地址→6 7 8 9 10 11 12 13 14 15 -------------------------------------------------------------------------------------- … | 50 | | | 6 | | | | -------------------------------------------------------------------------------------- |short int i |char a| |short int * pi| 看到没有：短整型指针变量pi的值为6，它就是I变量的内存起始地址。所以，这时当我们对*pi进行读写操作时，其实就是对i变量的读写操作。如：*pi=5; //就是等价于I=5; 你可以回看本系列的第二篇，那里有更加详细的解说。二．指针的地址与指向另一指针地址的指针在上一节中，我们看到，指针变量本身与其它变量一样也是在某个内存地址中的，如pi的内存起始地址是10。同样的，我们也可能让某个指针指向这个

C语言指针学习笔记

超强的指针学习笔记 C语言所有复杂的指针声明，都是由各种声明嵌套构成的。如何解读复杂指针声明呢？右左法则是一个既著名又常用的方法。不过，右左法则其实并不是C标准里面的内容，它是从C标准的声明规定中归纳出来的方法。C标准的声明规则，是用来解决如何创建声明的，而右左法则是用来解决如何辩识一个声明的，两者可以说是相反的。右左法则的英文原文是这样说的： The right-left rule:Start reading the declaration from the innermost parentheses,go right,and then go left.When you encounter parentheses,the direction should be reversed.Once everything in the parentheses has been parsed,jump out of it.Con tinue till the whole declaration has been parsed. 这段英文的翻译如下：右左法则：首先从最里面的圆括号看起，然后往右看，再往左看。每当遇到圆括号时，就应该掉转阅读方向。一旦解析完圆括号里面所有的东西，就跳出圆括号。重复这个过程直到整个声明解析完毕。笔者要对这个法则进行一个小小的修正，应该是从未定义的标识符开始阅读，而不是从括号读起，之所以是未定义的标识符，是因为一个声明里面可能有多个标识符，但未定义的标识符只会有一个。现在通过一些例子来讨论右左法则的应用，先从最简单的开始，逐步加深： int(*func)(int*p); 首先找到那个未定义的标识符，就是func，它的外面有一对圆括号，而且左边是一个*号，这说明func是一个指针，然后跳出这个圆括号，先看右边，也是一个圆括号，这说明(*fu nc)是一个函数，而func是一个指向这类函数的指针，就是一个函数指针，这类函数具有i nt*类型的形参，返回值类型是int。

指针的初始化和定义

每个指针都有一个与之关联的数据类型，该数据类型决定了指针所有指向的对象的类型。例如，一个int 型指针只能指向int 型对象。 1.指针变量的定义 C++语言使用* 号把一个标识符声明为指针： vector *pvec; int *p1, *p2; string *pstring; 提示：理解指针声明语句时，请从右向左阅读。 2.另一种声明指针的风格在定义指针变量时，可用空格符号* 与气候的标识符分别开来，如下： string* ps；也就是说，该语句把ps定义为一个指向string 类型对象的指针。这种指针声明风格容易引起这样的误解：把string * 理解为一种数据类型，认为在同意声明语句中定义的其他变量也指向string 类型对象的指针。如果使用下面的语句： string* p1, p2;

实际上只把ps1 定义为指针，而ps2并非指针，只是一个普通的string 对象而已。如果需要在一个声明语句中定义了两个指针，必须在每一个变量标识符前再加符号* 声明： string* ps1，*ps2; 3.指针的可能取值一个有效的指针必然是以下三种状态之一：1.保存一个特定对象的地址；2.指向某个对象后面的另一对象；3.是0值。若指针保存0值，表明它不指向任何对象。未初始化的指针是无效的，直到给该指针赋值后，才可以使用它。下面的定义是合法的： int ival = 1024; int *pi = 0; int *pi2 = &ival; int *pi3; pi = pi2; pi2 = 0; 4.避免使用未初始化的指针提示：很多运行时错误都源于使用了未初始化的指针。就像使用其他没有初始化的变量一样，使用未初始化的指针时的行为C++标准中并没有定义，它几乎总会导致运行时崩溃。然而，导致崩溃的这一原因很难发现。

C语言指针习题__附答案[1]

一、选择题 1.变量的指针，其含义是指该变量的_________. a)值b)地址 c)名d)一个标志 2．若有语句int *point,a=4;和point=&a;下面均代表地址的一组选项是_____. a)a,point,*&a b)&*a,&a,*point c)*&point,*point,&a d)&a,&*point ,point 3．若有说明;int *p,m=5,n;以下正确的程序段的是________. a)p=&n; b)p=&n; scanf("%d",&p); scanf("%d",*p); c)scanf("%d",&n); d)p=&n; *p=n; *p=m; 4. 以下程序中调用scanf函数给变量a输入数值的方法是错误的，其错误原因是________. main() { int *p,*q,a,b; p=&a; printf(“input a:”); scanf(“%d”,*p); …… } a)*p表示的是指针变量p的地址 b)*p表示的是变量a的值，而不是变量a的地址 c)*p表示的是指针变量p的值 d)*p只能用来说明p是一个指针变量 5. 已有变量定义和函数调用语句：int a=25; print_value(&a); 下面函数的正确输出结果是________. void print_value(int *x) { printf(“%d\n”,++*x);} a)23 b)24 c)25 d)26 6.若有说明：long *p,a;则不能通过scanf语句正确给输入项读入数据的程序段是 A) *p=&a；scanf("%ld"，p)；

第7章指针和指针变量

第七章指针知识目标： ●理解指针和指针变量的概念 ●掌握指针变量的定义与应用 ●理解指针与数组名之间的关系 ●掌握指针与数组的综合应用 ●掌握指针与字符串处理的设计方法 ●了解指针在函数中的应用能力目标： ●理解指针的作用 ●会通过指针类型使函数返回多个值 ●会通过指针访问数组元素 ●会使用指针作为数组的形参、实参 ●会通过指针访问字符串元素

7.1 指针的基本概念指针是Ｃ语言中的重要概念，也是Ｃ语言的重要特色。使用指针可以有效地表示复杂的数据结构；使用指针可以能方便地使用数组、字符串；使用指针可以使程序更加简洁、紧凑、高效。计算机硬件系统的内存储器中，拥有大量的存储单元（容量为１字节）。为了方便管理，必须为每一个存储单元编号，这个编号就是存储单元的“地址”。每个存储单元都有一个惟一的地址。变量的实质是计算机给程序分配的一定数量的存储空间，因此变量也有地址，scanf （“%d”，&a）中的&，本质上就是取出a的地址，使得输入的数据根据地址存放到相应的存储空间。那什么是指针呢？指针其实就是地址，二者同一个概念的两种说法。只不过指针更形象一些，就像一个针一样，可以指向某个地方。变量的指针就是变量的地址。存放变量地址的变量是指针变量。即在Ｃ语言中，允许用一个变量来存放指针，这种变量称为指针变量。因此，一个指针变量的值就是某个变量的地址或称为某变量的指针。指针与指针变量的关系如图7-1所示。图7-1 指针与指针变量的关系有了指针变量，我们访问变量就有了两种方式，直接访问和间接访问。直接访问:按变量名存取变量值，比如：i=3。间接访问:通过存放变量地址的变量去访问变量，比如图7-1中，i_pointer中存放了i的地址，我们就可以通过它先读取i的地址找到i变量的位置，然后读取i变量的值。为了表示指针变量和它所指向的变量之间的关系，在程序中用“*”符号表示“指向”，“*”也叫作指针运算符（去内容运算符），是一个与“&”互为相反的运算符。例如，i_pointer 代表指针变量，而*i_pointer是i_pointer 所指向的变量。因此，下面两

指针经典练习题及答案

二、程序题 1、计算字符串中子串出现的次数。要求:用一个子函数subString()实现, 参数为指向字符串和要查找的子串的指针,返回次数。 2、加密程序:由键盘输入明文，通过加密程序转换成密文并输出到屏幕上。算法：明文中的字母转换成其后的第4个字母,例如，A变成E(a变成e)， Z变成D,非字母字符不变；同时将密文每两个字符之间插入一个空格。例如，China转换成密文为G l m r e。要求：在函数change中完成字母转换，在函数insert中完成增加空格，用指针传递参数。 3、字符替换。要求用函数replace将用户输入的字符串中的字符t(T)都替换为e(E)，并返回替换字符的个数。 4、编写一个程序，输入星期，输出该星期的英文名。用指针数组处理。 5、有5个字符串，首先将它们按照字符串中的字符个数由小到大排列，再分别取出每个字符串的第三个字母合并成一个新的字符串输出（若少于三个字符的输出空格）。要求：利用字符串指针和指针数组实现。 6、定义一个动态数组，长度为变量n，用随机数给数组各元素赋值，然后对数组各单元排序，定义swap函数交换数据单元，要求参数使用指针传递。7、实现模拟彩票的程序设计：随机产生6个数字，与用户输入的数字进行比较，输它们相同的数字个数（使用动态内存分配）。 /*1、计算字符串中子串出现的次数。要求:用一个子函数subString()实现, 参数为指向字符串和要查找的子串的指针,返回次数。*/ #include int subString(char *a, char *b) { int i = 0; int j = 0; int m = 0; char *p = b; while(*a) { while(*a) { if(*a == *b) { break; } a++; } while(*b) { if(*a != *b)

第3章_栈和队列_习题参考答案

第四第3章栈和队列一、基础知识题 3.1 有五个数依次进栈：1，2，3，4，5。在各种出栈的序列中，以3，4先出的序列有哪几个。（３在４之前出栈）。【解答】34215 ，34251，34521 3.2 铁路进行列车调度时，常把站台设计成栈式结构，若进站的六辆列车顺序为：1，2，3，4，5，6，那么是否能够得到435612，325641，154623和135426的出站序列，如果不能，说明为什么不能；如果能，说明如何得到(即写出"进栈"或"出栈"的序列)。【解答】输入序列为123456，不能得出435612和154623。不能得到435612的理由是，输出序列最后两元素是12，前面4个元素（4356）得到后，栈中元素剩12，且2在栈顶，不可能让栈底元素1在栈顶元素2之前出栈。不能得到154623的理由类似，当栈中元素只剩23，且3在栈顶，2不可能先于3出栈。得到325641的过程如下：1 2 3顺序入栈，32出栈，得到部分输出序列32；然后45入栈，5出栈，部分输出序列变为325；接着6入栈并退栈，部分输出序列变为3256；最后41退栈，得最终结果325641。得到135426的过程如下：1入栈并出栈，得到部分输出序列1；然后2和3入栈，3出栈，部分输出序列变为13；接着4和5入栈，5，4和2依次出栈，部分输出序列变为13542；最后6入栈并退栈，得最终结果135426。 3.3 若用一个大小为6的数组来实现循环队列，且当前rear和front的值分别为0和3，当从队列中删除一个元素，再加入两个元素后，rear和front的值分别为多少？【解答】2和 4 3.4 设栈S和队列Q的初始状态为空，元素e1，e2，e3，e4，e5和e6依次通过栈S，一个元素出栈后即进队列Q，若6个元素出队的序列是e3，e5，e4，e6，e2，e1，则栈S的容量至少应该是多少？【解答】4 3.5 循环队列的优点是什么，如何判断“空”和“满”。【解答】循环队列解决了常规用0--m-1的数组表示队列时出现的“假溢出”（即队列未满但不能入队）。在循环队列中我们仍用队头指针等于队尾指针表示队空，而用牺牲一个单元的办法表示队满，即当队尾指针加1（求模）等于队头指针时，表示队列满。也有通过设标记以及用一个队头或队尾指针加上队中元素个数来区分队列的“空”和“满”的。 3.6 设长度为n的链队列用单循环链表表示，若只设头指针，则入队和出队的时间如何？若只设尾指针呢？【解答】若只设头指针，则入队的时间为O(n），出队的时间为O(1)。若只设尾指针，则入队和出队的时间均为O(1)。 3.7 指出下面程序段的功能是什么？ (1) void demo1(SeqStack S) {int i，arr[64]，n=0; while(!StackEmpty(S)) arr[n++]=Pop(S); for(i=0;i

C 语言中指针的运算详解

在C语言中，指针和数组名通常都可以混用。例如 char*p; 访问时，*p跟p[0]是一样的，*(p+1)跟p[1]是一样的。对于数组 char b[5]; 访问时，b[0]跟*b是一样的，b[2]跟*(b+2)是一样的。在一般的通信中（例如串口），通常都使用字节传输。而像float，long int之类的，有4字节。我的方法就是取它的地址，强制转换为char型指针，然后当作数组来用。float x; SBUF=((char*)&x)[0]; SBUF=((char*)&x)[1]; SBUF=((char*)&x)[2]; SBUF=((char*)&x)[3]; 接收时，刚好倒过来。更有趣的是，对于数组形式，数组名和后面的偏移量可以随便换。 char buff[10]; //或者用char*buff=&buffer; buff[3]=0xaa; 3[buff]=0xaa;//居然是一样的，倒塌... 因此，我认为编译器是这么干的：对于形如xxx[yyy]这样的表达式，会转化为*(xxx+yyy)，因此写成xxx[yyy]或者写成yyy[xxx]都无所谓了...非典用法，请勿乱用，出了事偶不负责... 指针变量可以进行赋值运算、加减算术运算以及关系运算。一、赋值运算 1、把一个指针变量的值赋给指向相同类型变量的另一个指针变量。如：

int x,*ptr_x,*ptr_y; ptr_x=&x; ptr_y=ptr_x; 指针ptr_x的值为变量x的地址。赋值语句将指针ptr_x的值赋给指针ptr_y,现在指针ptr_x和指针ptr_y指向同一个变量x。 2、把数组的首地址赋给指针变量。如： int a[5],*pa; pa=a; 由于数组元素占用内存中一块连续的存储单元，数组名就表示数组的首地址，所以可以将数组名直接赋给一个指向数组的指针变量pa。注意，在赋值语句的数组名a前面不用取址符&。二、算术运算数值变量可以进行加减乘除算术运算。而对于指针变量，由于它保存的一个内存地址，那么可以想象，对两个指针进行乘除运算是没有意义的。那么指针的算术就主要是指指针的移动。即通过指针递增、递减、加上或者减去某个整数值来移动指针指向的内存位置。 1、使用递增/递减运算符（++和--)将指针递增或递减。如： int*ptrnum,arr_num[10]; ptrnum=arr_num;

指向字符串的指针数组

在初学习C语言时，对于指针是最容易让人迷糊的，尤其对于指针数组，而且是指向字符串的指针数组，恐怕就更难理解了。下面本人给出一个例子，详细讲解指向字符串的指针数组的使用情况。希望给予学习C的朋友一点帮助。下述程序执行后，输出结果是什么？ #include char *p[2][3]={ "abc","defgh","ijkl","mnopqr","stuvw","xyz"}; main(){ printf("%c\n",***(p+1)); printf("%c\n",**p[0]); printf("%c\n",(*(*(p+1)+1))[4]); printf("%c\n",*(p[1][2]+2)); printf("%s\n",**(p+1)); } 答案是： m a w z mnopqr 答案解析：这里相当于定义了2行3列共6个元素的数组，数组的每一个元素都是指向字符的指针变量。其中p[0][0]指向串"abc"，p[0][1]指向串"defgh"，p[0][2] 指向串"ijkl"，p[1][0]指向串"mnopqr"，p[1][1]指向串"stuvw"，p[1][2] 指向串"xyz"。 1、printf("%c\n",***(p+1)); 这里的***(p+1)相当于*(*(*(p+1)+0)+0)，而*(*(p+1)+0)+0)的另一种容易懂的形式是p[1][0]，在多维数组中这两种写法等价。如上面所写的p[1][0]是指向串"mnopqr"，即保存的是串"mnopqr"的首地址，也即字母m的地址。因此***(p+1)是字母m 2、printf("%c\n",**p[0]); 这里的**p[0]等价于*(*(*(p+0)+0)+0)，也即*（p[0][0]），而p[0][0]）指向串"abc"，所以*（p[0][0]）是字符a 3、printf("%c\n",(*(*(p+1)+1))[4]); (*(*(p+1)+1))[4]等价于*（（p[1][1]）+4），而（p[1][1]）指向串"stuvw"，所以*（（p[1][1]）+4）是在串首向后移动4个单位的字符，也即w 4、printf("%c\n",*(p[1][2]+2)); 因为p[1][2]指向串"xyz"，而p[1][2]+2 就是串首向后移动2个字节（一个字节保存一个字符），也就是指向字符z,所以*(p[1][2]+2)是字符z

数据结构详细教案——栈和队列

数据结构教案第三章栈和队列

目录 3.1栈的基本概念 (2) 3.1.1 栈的抽象数据类型定义 (2) 3.1.2 顺序栈 (2) 3.1.3 链栈 (4) 3.2栈的应用 (4) 3.2.1 数制转换：将十进制数N转换成其他d进制数 (4) 3.2.2 括号匹配的检验 (4) 3.2.3 行输入处理程序 (4) 3.2.4 迷宫求解 (5) 3.2.5 表达式求值 (5) 3.3栈与递归的实现 (6) 3.4队列的基本概念 (6) 3.4.1 队列的抽象数据类型定义 (6) 3.4.2 链队列 (7) 3.4.3 循环队列 (8) 3.5队列与栈的应用 (8) 3.5.1 离散事件模拟 (8)

指针详解!很好的一篇学习指针的文章范文

第一章。指针的概念指针是一个特殊的变量，它里面存储的数值被解释成为内存里的一个地址。要搞清一个指针需要搞清指针的四方面的内容：指针的类型，指针所指向的类型，指针的值或者叫指针所指向的内存区，还有指针本身所占据的内存区。让我们分别说明。先声明几个指针放着做例子：例一： (1)int *ptr; (2)char *ptr; (3)int **ptr; (4)int (*ptr)[3]; (5)int *(*ptr)[4]; 如果看不懂后几个例子的话，请参阅我前段时间贴出的文章<<如何理解c和c ++的复杂类型声明>>。 1。指针的类型。从语法的角度看，你只要把指针声明语句里的指针名字去掉，剩下的部分就是这个指针的类型。这是指针本身所具有的类型。让我们看看例一中各个指针的类型： (1)int *ptr; //指针的类型是int * (2)char *ptr; //指针的类型是char * (3)int **ptr; //指针的类型是int ** (4)int (*ptr)[3]; //指针的类型是int(*)[3] (5)int *(*ptr)[4]; //指针的类型是int *(*)[4] 怎么样？找出指针的类型的方法是不是很简单？