当前位置：首页 > 教学文档 > 课件>谭浩强c语言课件指针

谭浩强c语言课件指针

2022-06-14 08:21:55 收藏本文下载本文

“臣妾做不到啊”通过精心收集，向本站投稿了10篇谭浩强c语言课件指针，以下是小编整理后的谭浩强c语言课件指针，希望能够帮助到大家。

谭浩强c语言课件指针

篇1：谭浩强c语言课件指针

谭浩强c语言课件关于指针

c语言中最难的'指针该如何去学习?又该如何使用精美生动的ppt对这一部分进行讲解，从而让学生更容易理解C语言复杂的指针呢?一起来看看这个精美的c语言课件吧!

谭浩强C语言课件-关于指针

篇2：c语言指针

一、数组的指针、指针数组以及指向指针的指针

考虑数组的指针的时候我们要同时考虑类型和维数这两个属性，换一句话，就是说一个数组排除在其中存储的数值，那么可以用类型和维数来位置表示他的种类。

A）一维数组

在c和c++中数组的指针就是数组的起始地址（也就第一个元素的地址），而且标准文档规定数组名代表数组的地址（这是地址数值层面的数组表示）。例如：

int a[10]; int *p;

p=&a[0]//和p=a是等价的：

因为a是数组名，所以他是该数组的地址，同时因为第一个元素为a[0]，那么&a[0]也代表了该数组的地址。但是我们是不是就说一个数组名和该数组的第一个元素的&运算是一回事呢？在一维的时候当时是的，但是在高维的时候，我们要考虑到维数给数组带来的影响。

a[10]是一个数组，a是数组名，它是一个包含10个int类型的数组类型，不是一般的指针变量噢！（虽然标准文档规定在c++中从int[]到int*直接转换是可以的，在使用的时候似乎在函数的参数为指针的时候，我们将该数组名赋值没有任何异样），a代表数组的首地址，在数字层面和a[10]的地址一样。这样我们就可以使用指针变量以及a来操作这个数组了。

所以我们要注意以下问题：

（1） p[i]和a[i]都是代表该数组的第i+1个元素；

（2） p+i和a+i代表了第i+1个元素的地址，所以我们也可以使用 *（p+I）和*（a+I）来引用对象元素；

（3）p+1不是对于指针数量上加一，而是表示从当前的位置跳过当前指针指向类型长度的空间，对于win32的int为4byte；

B)多维数组

对于二维数组a[4][6];由于数组名代表数组的起始地址，所以a（第一层）和第一个元素a[0][0]地址的数字是相同的，但是意义却是不同的。对于该数组我们可以理解为：a的一维数组（第一层），它有四个元素a[0]、a[1]、a[2]、a[3]（第二层），而每个元素又含有6个元素a[0][0],a[0][1],a[0][2],a[0][3],a[0][4]，a[0][5]（第三层）,…到此我们终于访问到了每个元素了，这个过程我们经历了：a->a[0]->a[0][0]；

整体来讲：a是一个4行5列的二维数组，a表示它指向的数组的首地址（第一个元素地址&a[0]）,同时a[0]指向一行，它是这个行的名字（和该行的第一个元素的首地址相同（第一个元素为地址&a[0][0]））。所以从数字角度说：a、a[0]、&a[0][0]是相同的，但是他们所处的层次是不同的。

既然a代表二维数组，那么a+i就表示它的第i+1个元素*（a+i）的地址，而在二维数组中

*（a+i）又指向一个数组，*（a+i）+j表示这个数组的第j+1个元素的地址，所以要访问这个元素可以使用 *（*（a+i）+j）（也就是a[i][j]）。

他们的示意图为（虚线代表不是实际存在的）：

对照这个图，如下的一些说法都是正确的（对于a[4][6]）：

a是一个数组类型，*a指向一个数组；

a+i指向一个数组；

a、*a和&a[0][0]数值相同；

a[i]+j和*（a+i）+j是同一个概念；

总结一下就是：我们对于二维指针a，他指向数组a[0，1，2，3]，使用*，可以使他降级到第二层次，这样*a就指向了第一个真正的数组。对于其他的情况我们也可以采用相同的方式，对于其他维数和类型的数组我们可以采用相类似的思想，

说到指向数组的指针，我们还可以声明一个指针变量让它指向一个数组。例如：

int （*p）[5]；

这时p就是一个指针，要指向一个含有5个int类型元素的数组，指向其他的就会出现问题。

这个时候我们可以使用上面的什么东西来初始化呢？

我们可以使用*a,*(a+1)，a[2]等。

原因很简单：我们在一个二维的数组中，那么表达方式有上面的相互类似的意义呢？只有 *a,*(a+1)，a[2]等，

C)指针数组

一个指针数组是指一个数组中的每个元素都是一个指针，例如：

int *p[10];//而不能是int (*p)[10]

或者

char *p[10];

此时p是一个指针（数值上和&p[0]一样）；

在前面有int t[10]；

int * pt=t;//使用pt指向t

那么这里我们用什么指向int *t[10]中的t呢？我们要使用一个指针的指针：

int **pt=t;

这是因为：在int *t[10]中，每个元素是指针，那么同时t又指向这个数组，数组上和&t[0]相同，也就是指向t[0]，指向一个指针变量，可以说是一个指针的指针了，所以自然要用

int **pt;

D)指针的指针

一个指针变量内部可以存储一个值，这个值是另外一个对象的地址，所以我们说一个指针变量可以指向一个普通变量，同样这个指针变量也有一个地址，也就是说有一个东西可以指向这个指针变量，然后再通过这个指针变量指向这个对象。那么如何来指向这个指针变量呢？由于指针变量本身已经是一个指针了（右值），那么我们这里就不能用一般的指针了，需要在指针上体现出来这些特点，我们需要定义指针的指针（二重指针）。

int *p1=&i; int**p2=&p1；

综合以上的所有点，下面是我们常常看到一些匹配（也是经常出错的地方）：

int a[3],b[2][3],c,*d[3]; void fun1(int *p)； void fun2(int (*p)[3]); void fun3(int **p); void fun4(int p[3]); void fun5(int p[]); void fun6(int p[2][3]); void fun7(int (&p)[3]);

函数不会产生编译时刻的可能值（但逻辑上不一定都对）

函数

不会产生编译时刻的可能值（但逻辑上不一定都对）

fun1

a, &a[i], *b ,b[i],&b[i][j] ,&c ,d[i]

fun2

b，b+i，

fun3

fun4

a, &a[i], *b ,b[i],&b[i][j] ,&c ,d[i]

fun5

a, &a[i], *b ,b[i],&b[i][j] ,&c ,d[i]

fun6

篇3：C语言指针

指针变量是包含内存地址的变量，它指向内存中的一块区域，通过指针的值，可以间接访问到相应的内存单元的数据，并做相应的修改，

1、指针的定义和简单使用

定义一个指针变量和定义一般的变量类似，只需在变量名前面加一个“*”。对一个指针变量赋值可以用取地址符&来获取到一个变量的地址，如果要获得指针指向的内存区域的数据，用解参考运算符*(也称为间接运算符，它返回其操作数指向的对象的值)。指针的值为NULL(NULL是stdio.h中定义的符号变量，实际上是0)说明其不指向任何的内存单元，0是唯一直接可以赋值给指针变量的整数值。实际上，*和&是互补的，当两个运算符连续应用于一个指针变量时，无论顺序如何，运算结果相同。同时可以用printf中的格式化字符串%p来输出指针变量的值，下面是一个简单的程序。

[cpp]

#include

int main

{

int a;

a=9;

//定义并初始化一个指针，命名就可以看出

int *aPtr=NULL;

//将指针指向变量a

aPtr=&a;

printf(“The address of a is %p”

“nThe value of aPtr is %p”,&a,aPtr);

printf(“nnThe value of a is %d”

“nThe value of *aPtr is %d”,a,*aPtr);

printf(“nnShowing that * and & are complements of ”

“each othern&*aPtr = %p”

“n*&aPtr = %pn”,&*aPtr,*&aPtr);

return 0;

}

2、用指针做函数的参数

2.1 通过指针实现的引用传递

程序设计语言的参数传递方式，大致分两种：值传递和引用传递。C语言中没有引用传递，但是C语言通过指针间接实现了引用传递。通过用指针变量作为函数的参数，可以传递变量的地址(只需要在变量前面加上&运算符就可以)，这样，用该地址就可以访问到主调函数中的该变量的内存地址，并可以进行相应的修改。这样，在函数执行完毕之后，修改仍然可以得到保留。

2.2 const

const限定符可以告诉编译器特定的变量的值是不能被修改的。如果想确保函数不会修改传递进来的参数值，应该将参数声明为const。这样对于C语言中用指针实现的引用传递，有四种情况：指向非常量数据的非常量指针(int *aPtr)，指向非常量数据的常量指针(int *const aPtr)，指向常量数据的非常量指针(const int *aPtr)和指向常量数据的常量指针(const int * const aPtr)。简单的说，就是指针变量自身和指针指向的变量都有可能是const，这样就产生了四种情况，这四种情况提供了四种不同的访问权限，下面分别解释。

指向非常量数据的非常量指针(int *aPtr)：指针的值本身和指针指向变量的值都可以在函数中被修改。

指向非常量数据的常量指针(int *const aPtr)：指针的值不能被修改，但是指针指向的变量的值可以被修改。

指向常量数据的非常量指针(const int *aPtr)：指针指向的值不能被修改，但是指针本身的值可以被修改。

指向常量数据的常量指针(const int * const aPtr)：指针本身和指针指向变量的值都不能被修改。

3、sizeof和指针运算

3.1 sizeof

sizeof是C语言中特殊的一元运算符，可以应用在变量名称、数据类型和常量之前，它在程序编译期间以字节为单位来确定数组或其他数据类型的大小。当应用于数组时，sizeof返回数组中的字节总数。如float a[20]，sizeof(a)的值应该是4*20，80。当然，如果想获得数组的大小可以采用sizeof(a)/sizeof(float)。

3.2 指针运算

实际上，指针变量可以进行的算术操作是有限的：递增，递减，将指针和整数相加，从指针中减去一个整数或者一个指针减去另一个指针，

需要注意的是，对于指针的算术运算，其单位长度并不是一般意义上的1，而是sizeof(TYPE)。这样，如果float a[14]; float *aPtr=a;(或者int *aPtr=&a[0]); aPtr++;这样aPtr应该指向的是数组a的第二个元素，也就是a[1]，这里的单位长度就是sizeof(float)。同样地，如果aPtr=aPtr+5;，这样aPtr又指向了数组a的第6个元素。如果aPtr-a，这样可以得到两个指针之间的元素间隔个数。应该是6。

进行指针运算要注意：

(1)如果将一个指针的值赋给另外一个指针，那么这两个指针的类型必须相同，否则应该用类型转换运算符进行类型转换。但是，有一个例外就是指向void类型的指针，它是通用指针，可以代表任何指针类型。因此，所有指针类型都可以赋值给void指针，而void指针也可以赋值给任何类型的指针，而不需要任何类型转换运算符。但是，void指针不能解参考，编译器知道指向int类型的指针引用的是32位计算机上的4个字节内存，但指向void的指针仅包含未知数据类型的内存位置，也就是说，编译器不知道指针所引用的字节数。编译器必须知道数据类型，才能确定所引用的字节数。

(2)除非两个指针变量都指向的是一个数组中的元素，否则对它们相减的结果没有任何意义，因为我们不能假设两个变量在内存中是连续的。

4、指针和数组

4.1 数组和指针的共性

实际上，数组名称的本质是一个常量指针。因此，int a[6]; int *aPtr;定义一个数组和指针之后，通过a[3]，*(a+3)和*(aPtr+3)都可以访问到数组的第四个元素的值。但是区别在于，aPtr=aPtr+3;这样aPtr就指向了a数组的第四个元素，但是，不能a=a+3;，因为a是一个数组名，它是一个常量指针它的值不能被修改，更加具体地说，它应该是一个指向非常量数据的常量指针。

4.2 指针数组

数组元素也可以是指针类型，指针数组常见的用途就是构成由字符串组成的数组，简单地说就是字符串数组，数组中的每一个元素都是字符串。下面是一个例子，const限定符说明不能修改每个元素指针所指向的字符串。

[cpp]

#include

int main()

{

const char *suit[4]={“Hearts”,“Diamonds”,“Clubs”,“Spades”};

int i;

for(i=0;i<4;i++)

printf(“sizeof pointer to ”%s“ :%dn”,suit[i],sizeof(suit[i]));

printf(“nsizeof suit:%dn”,sizeof(suit));

return 0;

}

运行结果如下：

从这个例子中，可以看出const char *suit[4]={“Hearts”,“Diamonds”,“Clubs”,“Spades”};定义了一个指针数组，但是，其中的每个元素只是一个指针，而不是数组名(如果是数组名的话，sizeof的结果不应该都是4)。这样定义字符串数组可以节省空间。

5、函数指针

和数组名实际上就是数组第一个元素在内存中的地址类似，函数迷你实际上就是执行函数任务的代码在内存中的起始地址。函数指针包含函数在内存中的地址，可以传递给函数、从函数返回、存储在数组中或者是赋值给其它的函数指针，下面是两个函数指针的例子。

(1) 用函数指针实现升序/降序排序

[cpp]

#include

#define SIZE 10

int ascending(int a,int b)

{

return a>b;

}

int descending(int a,int b)

{

return a

}

void swap(int *aPtr,int *bPtr)

{

int temp=*aPtr;

*aPtr=*bPtr;

*bPtr=temp;

}

篇4：C语言指针讲解

指针是C语言的一种数据类型，类似于C中的其他类型，例如int ,char 等，既然指针是一种类型，当我们定义该类型变量，该类型变量就称为指针变量。

C中有了指针就有了指向。指向：指针变量指向本身保存的内容（地址或指针）所表示的内存单元。

C语言指针是一个特殊的变量，其里面储存的数值被解释成为内存里的一个地址。

在计算机中，所有对数据的操作，都是通过其地址进行的，指针让程序的效率更高，代码更少。

在学习指针的时间，一定要理解并区分指针的四个感念：指针的类型，指针所指向的类型，指针的值，指针本身所占据的内存区。

指针变量定义的一般形式：类型说明符* 变量名。类型说明符：表示该指针变量指向的变量的数据类型，并且该指针变量只能指向该数据类型的变量。这是指针变量的特征。

*:表示该变量的指针变量。这也是指针变量的特征。

变量名：表示指针变量的名称。

例如：char *pstu; *表示pstu是一个指针变量，char是指针变量pstu指向的变量的数据类型。整个语句表示定义了一个指向char类型变量的指针变量。但具体pstu指向哪个char类型的变量，这就要看在使用pstu时，给pstu赋予的值，值是什么就指向哪。

讲指针不得不说的两个运算符。取地址运算符&和取值运算符*.通过取地址运算符&可以获得某个变量的地址，用取值运算符可以获得某个地址中存放的数据。

指针变量使用前，先定义，给指针初始化以后，也就是赋值以后才能使用。在赋值时只能赋兼容类型的值。

例如：

#include

void main

{

int name,stuName=1;

int *pStu;

int *pNew;

pStu = &stuName;

pNew = pStu;

name = *pNew;

printf（“%dn%dn%dn%dnn”,stuName,*pStu,name,*pNew）；

printf（“%dn%dn%dn%dnn”,&stuName,&pStu,&name,&pNew）；

printf（“%dn%dn”,pStu,pNew）；

}

从打印的值完全可以理解内存中存放的是什么。

简单修改：

#include

void main（）

{

int name,stuName=1;

int *pStu = NULL;

int *pNew = NULL;

pStu = &stuName;

pNew = *（&pStu）；

name = *pNew;

*pStu =100;

printf（“%dn%dn%dn%dnn”,stuName,*pStu,name,*pNew）；

printf（“%dn%dn%dn%dnn”,&stuName,&pStu,&name,&pNew）；

printf（“%dn%dn”,pStu,pNew）；

}

指针与整数的加法。主要用于数组中。

int arr []= {1,2,3,4,5};<罚www.2cto.com/kf/ware/vc/“ target=”_blank“ class=”keylink“>vcD4KPHA+aW50ICpwTmV3ID0gYXJyOzwvcD4KPHA+cE5ldyYjNDM7JiM0Mzs7PC9wPgo8cD5wTmV3ID0gcE5ldyAmIzQzOyAyOzwvcD4KPHA+yv3X6cP7vs3Kx7Xa0ru49sr91+nUqsvYtcS12Na3oaMgaW50ICpwTmV3ID0gJmFtcDsgYXJyWzBdOzwvcD4KPHA+cE5ldyA9IHBOZXcgJiM0MzsgNzsgcE5ld7XE1rjP8tLRvq3Uvb3no6y+38zl1rjP8rK71qq1wKOsv8nE3MrH0tG05tTatcS12Na3u/LOtNaqtdjWt6Os1NrKudPDJiMyMDU0MDvKx7vht6LJ+s601qq1xLTtzvOho9TayrnTw9a41euy2df3yrGjrNK7tqjSqtei0uLKx7fxs6yz9sHLyv3X6bXEtPPQoaGjPGJyPgo8L3A+CjxwPsn5w/fSu7j21rjV66Gj1rjV67Hkwb/Kx7Hkwb+hozwvcD4KPHA+yv3X6da41eujurrN1rjV67Hkwb/Tw7eou/mxvtK70fmhozwvcD4KPHA+1rjV68r91+mjutK7z7XB0Na4z/LNrNK7yv2+3cDg0M21xNa41eux5MG/tcS8r7rPo6yzxs6q1rjV68r91+mho9a41evK/dfptcTL+dPQ1KrL2La8ysfWuNXrseTBv6Gjy/zDx7HY0Ou+39PQz+DNrLXEtKK05sDg0M2jrLHY0OvWuM/yz+DNrLXEyv2+3cDg0M2hozwvcD4KPHA+wODQzcu1w/e3+yAgKsr91+nD+1vK/dfps6S2yF07PC9wPgo8cD7A/cjno7ppbnQgICAqYXJyWzVdOzwvcD4KPHA+Y2hhciAqc3RyW10gPSB7”Chain“,”Beijing“,”LongMai“};

-）常量指针（指向可以修改，指向对应的值不可以修改）

常量是形容词，指针是名词，以指针为中心的一个偏正结构短语，

这样看，常量指针本质是指针，常量修饰它，表示这个指针乃是一个指向常量的指针（变量）。

指针指向的对象是常量，那么这个对象不能被更改。

在C/C++中，常量指针是这样声明的：

1）const int *p;

2）int const *p;

常量指针的使用要注意，指针指向的对象不能通过这个指针来修改，可是仍然可以通过原来的声明修改，也就是说常量指针可以被赋值为变量的地址，之所以叫做常量指针，是限制了通过这个指针修改变量的值。

例如：

int a = 5,b=6;

const int *c = &a; // 这是合法的，非法的是对c的使用

c = &b; //合法

*c = 6; // 非法，但可以这样修改c指向的对象的值：a = 6;

const int *d = &b; // b是常量，d可以指向b,d被赋值为b的地址是合法的

二）指针常量（指向不可以修改，指向对应的值可以修改）

指针是形容词，常量是名词。这回是以常量为中心的一个偏正结构短语。那么，指针常量的本质是一个常量，而用指针修饰它，那么说明这个常量的值应该是一个指针。

指针常量的值是指针，这个值因为是常量，所以不能被赋值。

在C/C++中，指针常量这样声明：

int a;

int *const b = &a; //const放在指针声明操作符的右侧

只要const位于指针声明操作符右侧，就表明声明的对象是一个常量，且它的内容是一个指针，也就是一个地址。上面的声明可以这么读，声明了一个常量b,它的值是变量a的地址（变量a的地址，不就是指向变量a的指针吗）。

因为指针常量是一个常量，在声明的时候一定要给它赋初始值。一旦赋值，以后这个常量再也不能指向别的地址。

虽然指针常量的值不能变，可是它指向的对象是可变的，因为我们并没有限制它指向的对象是常量。

因此，有这么段程序：

char *a = ”abcde1234“;

char *b = ”bcde“;

char *const c = &a;

下面的操作是可以的。

a[0] = 'x'; // 我们并没有限制a为常量指针（指向常量的指针）

或者

*c[0] = 'x' // 与上面的操作一致

三）指向常量的指针常量（指向不可以修改，指向对应的值也不可以修改）

顾名思议，指向常量的指针常量就是一个常量，且它指向的对象也是一个常量。

因为是一个指针常量，那么它指向的对象当然是一个指针对象，而它又指向常量，说明它指向的对象不能变化。

在C/C++中，这么声明：

篇5：C语言实验报告《指针》

C语言实验报告《指针》 -实习报告

学号：__________ 姓名：__________ 班级：__________ 日期：__________ 指导教师：__________ 成绩：__________实验五指针一、实验目的1、掌握指针的概念、会定义和使用指针变量2、掌握指向数组的.指针变量3、掌握字符串指针的使用二、实验内容1、输入3个字符串，按由小到大的顺序输出。（习题10.2）2、写一函数，求一个字符串的长度。在main函数中输入字符串，并输出其长度。（习题10.6）3、完善程序，要求使用函数功能：将一个数字字符串转换成一个整数（不得调用C语言提供的将字符串转换为整数的函数）。例如，若输入字符串“-1234”，则函数把它转换为整数值-1234。#include #include long fun(char *p){填写程序}void main{char s[6];long n;printf(Enter a string:n);gets(s);n=fun(s);printf(%ldn,n);}一、三、实验步骤与过程第一┆范文网www.diyiFANWEN.com整理该文章，版权归原作者、原出处所有...四、程序调试记录

篇6：六:指针（C语言）

指针是C语言中广泛使用的一种数据类型，运用指针编程是C语言最主要的风格之一。利用指针变量可以表示各种数据结构；能很方便地使用数组和字符串；并能象汇编语言一样处理内存地址，从而编出精练而高效的程序。指针极大地丰富了C语言的功能。学习指针是学习C语言中最重要的一环，能否正确理解和使用指针是我们是否掌握C语言的一个标志。同时，指针也是C语言中最为困难的一部分，在学习中除了要正确理解基本概念，还必须要多编程，上机调试。只要作到这些，指针也是不难掌握的。

指针的基本概念在计算机中，所有的数据都是存放在存储器中的。一般把存储器中的一个字节称为一个内存单元，不同的数据类型所占用的内存单元数不等，如整型量占2个单元，字符量占1个单元等，在第二章中已有详细的介绍。为了正确地访问这些内存单元，必须为每个内存单元编上号。根据一个内存单元的编号即可准确地找到该内存单元。内存单元的编号也叫做地址。既然根据内存单元的编号或地址就可以找到所需的内存单元，所以通常也把这个地址称为指针。内存单元的指针和内存单元的内容是两个不同的概念。可以用一个通俗的例子来说明它们之间的关系。我们到银行去存取款时，银行工作人员将根据我们的帐号去找我们的存款单，找到之后在存单上写入存款、取款的金额。在这里，帐号就是存单的指针，存款数是存单的内容。对于一个内存单元来说，单元的地址即为指针，其中存放的数据才是该单元的内容。在C语言中，允许用一个变量来存放指针，这种变量称为指针变量。因此，一个指针变量的值就是某个内存单元的地址或称为某内存单元的指针。图中，设有字符变量C，其内容为“K”(ASCII码为十进制数 75)，C占用了011A号单元(地址用十六进数表示)。设有指针变量P，内容为011A，这种情况我们称为P指向变量C，或说P是指向变量C的指针。严格地说，一个指针是一个地址，是一个常量。而一个指针变量却可以被赋予不同的指针值，是变。但在常把指针变量简称为指针。为了避免混淆，我们中约定：“指针”是指地址，是常量，“指针变量”是指取值为地址的变量。定义指针的目的是为了通过指针去访问内存单元。

既然指针变量的值是一个地址，那么这个地址不仅可以是变量的地址，也可以是其它数据结构的地址。在一个指针变量中存放一

个数组或一个函数的首地址有何意义呢？因为数组或函数都是连续存放的。通过访问指针变量取得了数组或函数的首地址，也就找到了该数组或函数。这样一来，凡是出现数组，函数的地方都可以用一个指针变量来表示，只要该指针变量中赋予数组或函数的首地址即可。这样做，将会使程序的概念十分清楚，程序本身也精练，高效。在C语言中，一种数据类型或数据结构往往都占有一组连续的内存单元。用“地址”这个概念并不能很好地描述一种数据类型或数据结构，而“指针”虽然实际上也是一个地址，但它却是一个数据结构的首地址，它是“指向”一个数据结构的，因而概念更为清楚，表示更为明确。这也是引入“指针”概念的一个重要原因。

指针变量的类型说明

对指针变量的类型说明包括三个内容：

(1)指针类型说明，即定义变量为一个指针变量；

(2)指针变量名；

(3)变量值(指针)所指向的变量的数据类型，

其一般形式为：类型说明符 *变量名；

其中，*表示这是一个指针变量，变量名即为定义的指针变量名，类型说明符表示本指针变量所指向的变量的数据类型。

例如： int *p1;表示p1是一个指针变量，它的值是某个整型变量的地址。或者说p1指向一个整型变量。至于p1究竟指向哪一个整型变量，应由向p1赋予的地址来决定。

再如：

staic int *p2; /*p2是指向静态整型变量的指针变量*/

float *p3; /*p3是指向浮点变量的指针变量*/

char *p4; /*p4是指向字符变量的指针变量*/ 应该注意的是，一个指针变量只能指向同类型的变量，如P3 只能指向浮点变量，不能时而指向一个浮点变量，时而又指向一个字符变量。

指针变量的赋值

指针变量同普通变量一样，使用之前不仅要定义说明，而且必须赋予具体的值。未经赋值的指针变量不能使用，否则将造成系统混乱，甚至死机。指针变量的赋值只能赋予地址，决不能赋予任何其它数据，否则将引起错误。在C语言中，变量的地址是由编译系统分配的，对用户完全透明，用户不知道变量的具体地址。 C语言中提供了地址运算符&来表示变量的地址。其一般形式为： & 变量名；如&a变示变量a的地址，&b表示变量b的地址。变量本身必须预先说明。设有指向整型变量的指针变量p，如要把整型变量a 的地址赋予p可以有以下两种方式：

(1)指针变量初始化的方法 int a;

int *p=&a;

(2)赋值语句的方法 int a;

int *p;

p=&a;

不允许把一个数赋予指针变量，故下面的赋值是错误的： int *p;p=1000; 被赋值的指针变量前不能再加“*”说明符，如写为*p=&a 也是错误的

指针变量的运算

指针变量可以进行某些运算，但其运算的种类是有限的。它只能进行赋值运算和部分算术运算及关系运算。

1.指针运算符

(1)取地址运算符&

取地址运算符&是单目运算符，其结合性为自右至左，其功能是取变量的地址。在scanf函数及前面介绍指针变量赋值中，我们已经了解并使用了&运算符。

(2)取内容运算符*

取内容运算符*是单目运算符，其结合性为自右至左，用来表示指针变量所指的变量。在*运算符之后跟的变量必须是指针变量。需要注意的是指针运算符*和指针变量说明中的指针说明符* 不是一回事。在指针变量说明中，“*”是类型说明符，表示其后的变量是指针类型。而表达式中出现的“*”则是一个运算符用以表示指针变量所指的变量。

main(){

int a=5,*p=&a;

printf (”%d“,*p);

篇7：《指针》C语言实验报告

《指针》C语言实验报告

C语言实验报告《指针》学号：__________ 姓名：__________ 班级：__________ 日期：__________

指导教师：__________ 成绩：__________

实验五指针

一、实验目的.

1、掌握指针的概念、会定义和使用指针变量

2、掌握指向数组的指针变量

3、掌握字符串指针的使用

二、实验内容

1、输入3个字符串，按由小到大的顺序输出。（习题10.2）

2、写一函数，求一个字符串的长度。在main函数中输入字符串，并输出其长度。（习题10.6）

3、完善程序，要求使用函数功能：将一个数字字符串转换成一个整数（不得调用C语言提供的将字符串转换为整数的函数）。例如，若输入字符串“-1234”，则函数把它转换为整数值-1234。

#include

long fun(char *p)

填写程序

void main

char s[6];

long n;

printf(”Enter a string: “);

gets(s);

n=fun(s);

printf(”%ld ",n);

三、实验步骤与过程

四、程序调试记录

篇8：C语言指针笔试题

1. char * const p;

char const * p

const char *p

上述三个有什么区别?

char * const p; //常量指针，p的值不可以修改

char const * p;//指向常量的指针，指向的常量值不可以改

const char *p; //和char const *p

2. char str1 = “abc”;

char str2 = “abc”;

const char str3 = “abc”;

const char str4 = “abc”;

const char *str5 = “abc”;

const char *str6 = “abc”;

char *str7 = “abc”;

char *str8 = “abc”;

cout << ( str1 == str2 ) << endl;

cout << ( str3 == str4 ) << endl;

cout << ( str5 == str6 ) << endl;

cout << ( str7 == str8 ) << endl;

打印结果是什么?

解答：结果是：0 0 1 1

str1,str2,str3,str4是数组变量，它们有各自的内存空间;而str5,str6,str7,str8是指针，它们指向相同的常量区域

3. 以下代码中的两个sizeof用法有问题吗?

void UpperCase( char str ) // 将 str 中的小写字母转换成大写字母

{

for( size_t i=0; i

if( ‘a’<=str[i] && str[i]<=’z’ )

str[i] -= (‘a’-'A’ );

}

char str = “aBcDe”;

cout << “str字符长度为: ” << sizeof(str)/sizeof(str[0]) << endl;

UpperCase( str );

cout << str << endl;

答：函数内的sizeof有问题。

根据语法，sizeof如用于数组，只能测出静态数组的大小，无法检测动态分配的或外部数组大小。

函数外的str是一个静态定义的数组，因此其大小为6，

函数内的str实际只是一个指向字符串的指针，没有任何额外的与数组相关的信息，因此sizeof作用于上只将其当指针看，一个指针为4个字节，因此返回4。

4. main

{

int a[5]={1,2,3,4,5};

int *ptr=(int *)(&a+1);

printf(“%d,%d”,*(a+1),*(ptr-1));

}

输出结果是什么?

答案：输出：2,5

*(a+1)就是a[1]，*(ptr-1)就是a[4],执行结果是2，5

&a+1不是首地址+1，系统会认为加一个a数组的偏移，是偏移了一个数组的大小(本例是5个int)

int *ptr=(int *)(&a+1);

则ptr实际是&(a[5]),也就是a+5

原因如下：

&a是数组指针，其类型为 int (*)[5];

而指针加1要根据指针类型加上一定的值，不同类型的指针+1之后增加的大小不同。

a是长度为5的int数组指针，所以要加 5*sizeof(int)

所以ptr实际是a[5]

但是prt与(&a+1)类型是不一样的(这点很重要)

所以prt-1只会减去sizeof(int*)

a,&a的地址是一样的，但意思不一样

a是数组首地址，也就是a[0]的地址，&a是对象(数组)首地址，

a+1是数组下一元素的地址，即a[1],&a+1是下一个对象的地址，即a[5].

篇9：C语言指针笔试题

1. 请问以下代码有什么问题：

int main

{

char a;

char *str=&a;

strcpy(str,”hello”);

printf(str);

return 0;

}

答案：没有为str分配内存空间，将会发生异常。问题出在将一个字符串复制进一个字符变量指针所指地址。虽然可以正确输出结果，但因为越界进行内在读写而导致程序崩溃。

2. char* s=”AAA”;

printf(“%s”,s);

s[0]=’B';

printf(“%s”,s);

有什么错?

答案：

“AAA”是字符串常量。s是指针，指向这个字符串常量，所以声明s的时候就有问题。

cosnt char* s=”AAA”;

然后又因为是常量，所以对是s[0]的赋值操作是不合法的。

3. int (*s[10])(int) 表示的是什么?

答案：int (*s[10])(int) 函数指针数组，每个指针指向一个int func(int param)的函数。

4. 有以下表达式：

int a=248; b=4;

int const c=21;

const int *d=&a;

int *const e=&b;

int const *f const =&a;

请问下列表达式哪些会被编译器禁止?为什么?

*c=32;d=&b;*d=43;e=34;e=&a;f=0x321f;

答案：

*c 这是个什么东东，禁止

*d 说了是const，禁止

e = &a 说了是const 禁止

const *f const =&a; 禁止

5. #include

#include

void getmemory(char *p)

{

p=(char *) malloc(100);

strcpy(p,”hello world”);

}

int main( )

{

char *str=NULL;

getmemory(str);

printf(“%s/n”,str);

free(str);

return 0;

}

分析一下这段代码

答案：程序崩溃，getmemory中的malloc 不能返回动态内存， free对str操作很危险

博主：getmemory中p是形参，是一个指针变量，getmemory(str)调用后，传入的是指针变量保存的对象地址，p=(char *) malloc(100)实际上是把申请的动态内存空间的首地址付给p指向的地址(即str指向的地址null)，这个是错误的。应该修改成指向指针的指针void getmemory(char p)，这样malloc返回的地址付给*p(即str变量本身)。

6 char szstr[10];

strcpy(szstr,”0123456789″);

产生什么结果?为什么?

答案：长度不一样，会造成非法的OS

篇10：C语言指针笔试题

11.要对绝对地址0×100000赋值，我们可以用(unsigned int*)0×100000 = 1234;

那么要是想让程序跳转到绝对地址是0×100000去执行，应该怎么做?

答案：*((void (*)( ))0×100000 ) ( );

首先要将0×100000强制转换成函数指针,即:

(void (*))0×100000

然后再调用它:

*((void (*))0×100000);

用typedef可以看得更直观些:

typedef void(*) voidFuncPtr;

*((voidFuncPtr)0×100000);

12. 分析下面的程序：

void GetMemory(char p,int num)

{ //p，指向指针的指针，*p，p指向的指针(即str)，p，最终的对象，str指向的单元

*p=(char *)malloc(num); //申请空间首地址付给传入的被p指向的指针，即str

}

int main

{

char *str=NULL;

GetMemory(&str,100); //传入指针变量本身的地址

strcpy(str,”hello”);

free(str);

if(str!=NULL)

{

strcpy(str,”world”);

}

printf(“n str is %s”,str); 软件开发网

getchar;

}

问输出结果是什么?

答案：输出str is world。

free 只是释放的str指向的内存空间,它本身的值还是存在的.所以free之后，有一个好的习惯就是将str=NULL.

此时str指向空间的内存已被回收,如果输出语句之前还存在分配空间的操作的话,这段存储空间是可能被重新分配给其他变量的,

尽管这段程序确实是存在大大的问题(上面各位已经说得很清楚了)，但是通常会打印出world来。

这是因为，进程中的内存管理一般不是由操作系统完成的，而是由库函数自己完成的。

当你malloc一块内存的时候，管理库向操作系统申请一块空间(可能会比你申请的大一些)，然后在这块空间中记录一些管理信息(一般是在你申请的内存前面一点)，并将可用内存的地址返回。但是释放内存的时候，管理库通常都不会将内存还给操作系统，因此你是可以继续访问这块地址的。

13.char a[10];

strlen(a)为什么等于15?

#include “stdio.h”

#include “string.h”

void main

{

char aa[10];

printf(“%d”,strlen(aa));

}

答案：sizeof和初不初始化，没有关系;

strlen和初始化有关。

14.char (*str)[20];/*str是一个数组指针，即指向数组的指针.*/

char *str[20];/*str是一个指针数组，其元素为指针型数据.*/

15.

#include

typedef struct AA

{

int b1:5;

int b2:2;

}AA;

void main

{

AA aa;

char cc[100];

strcpy(cc,”0123456789abcdefghijklmnopqrstuvwxyz”);

memcpy(&aa,cc,sizeof(AA));

cout << aa.b1 <

cout << aa.b2 <

}

输出结果是多少?

答案：-16和1

首先sizeof(AA)的大小为4,b1和b2分别占5bit和2bit.经过strcpy和memcpy后,aa的4个字节所存放的值是: 0,1,2,3的ASC码，即00110000,00110001,00110010,00110011所以，最后一步：显示的是这4个字节的前5位，和之后的2位分别为：10000,和01，因为int是有正负之分

【谭浩强c语言课件指针】相关文章：

1.C语言实验报告《指针》

2.C语言指针笔试题

3.深度理解C语言的指针与数组

4.c中指针指针、指针的指针、指针数组和数组指针