实验六指针（C++）

梦里梦外; 2022-04-24 02:42 274阅读 0赞

### **实验六  指针（C++）** ###

**一、****实验目的**

1、掌握指针的概念、指针变量定义格式以及指针的运算；

2、掌握指针与数组、函数的关系；

3、理解内存动态分配的含义、熟练掌握内存动态分配方法；

4、掌握递归函数的定义方法。

**二、****实验内容**

1、上机验证下列程序的运行结果（有错误的话自己补充完善）

(1) void main()

｛

int i,j,\*pi,\*pj;     //此处的\*表示定义指针变量，而非间接运算符

pi=&i;

pj=&j;

i=5;j=7;

cout<<i<<’\\t’<<j<<’\\t’<<pi<<’\\t’<<pj;

cout<<&i<<’\\t’<<\*&i<<’\\t’<<&j<<’\\t’<<\*&j;

运行结果：

上述结果中，pi与&i,pj与&j是地址值，随编译程序而变化，不确定。

(2) int main()   //C语言程序，要了解

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

int \*p,i;

p=a;    //将数组a首地址送给p

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

printf("%d,%d,%d,%d\\n",a\[i\],p\[i\],\*(p+i),\*(a+i));  //与cout功能差不多

运行结果：

1,1,1,1

2,2,2,2

3,3,3,3

通过这两道题目，希望学生掌握数组元素与指向数组的指针的不同。

a\[i\]表示数组中下标为i的元素。

a\[i\]←p\[i\]←\*(p+i)←\*(a+i)

a是数组名，表示数组首地址，(p+i)表示数组中第i个元素的地址，\*(p+i) 相当于a\[i\]。

(3)通过如下的问题理解递归函数的定义与调用（递归未讲，可以后做）

//\#include “stdio.h”

void f(char \*st,int i)

st\[i\]=’\\0’;

cout<<st;   // printf(“%s\\n”,st);

if (i>1) f(st,i-1);

void main()

char st\[\]=”abcd”;

f(st,4);

补充完整，运行时输出为\_\_\_\_\_\_\_\_

(4)下面程序的主函数中能保证p\[0\]输出1，p\[1\]输出2吗？如何修改以保证之（提示：在函数f中使用new生成动态数组；在main中用delete释放。）

\#include<iostream>

using namespace std;

int \*f()

int list\[\]=\{1,2,3,4\};

return list;

void main()

int \*p=f();

cout<<p\[0\]<<endl;

cout<<p\[1\]<<endl;

2、程序设计

(1)编写函数检查字符串s1是否为字符串s2的子串，若是，返回第一次匹配的下标，否则返回-1。在主程序中输入字符串s1与s2，调用函数实现。

函数原型：int indexof(const char \*s1,const char \*s2);

(2)编写一个函数将以字符串形式表示的一个16进制数转换为10进制数，并在主函数中测试。函数原型 int parseHex(const char \*const hexString);

如：调用函数 parseHex(“A5”);返回165

3、猴子吃桃：猴子第一天摘若干桃子，当即吃了一半，还不过瘾，又吃了一个。第二天又将剩下的桃子吃掉一半，又多吃一个，以后每天如此，到第10天，发现只剩最后一个桃子，问，第一天猴子共摘多少桃子（用递归实现）。

4、主程序中建立一动态数组（使用new），数组元素及元素个数由键盘输入，动态调试观察指针及指针指向的内容；设计一个函数对数组由小到大排序；主程序中用指针方式输出数组元素；最后释放数组内存（delete）。

**三、****实验步骤、算法与结果分析**

1、上机验证下列程序的运行结果（有错误的话自己补充完善）

(1)

void main()
    
        ｛
    
           int i,j,*pi,*pj;     //此处的*表示定义指针变量，而非间接运算符
    
           pi=&i;
    
           pj=&j;
    
           i=5;j=7;
    
           cout<<i<<’\t’<<j<<’\t’<<pi<<’\t’<<pj;
    
           cout<<&i<<’\t’<<*&i<<’\t’<<&j<<’\t’<<*&j;
    
        }

运行结果：

上述结果中，pi与&i,pj与&j是地址值，随编译程序而变化，不确定。

#include<iostream>
    
    using namespace std;
    
    void main()
    
    {
    
        int i , j , *pi , *pj;      //此处的*表示定义指针变量，而非间接运算符
    
        pi=&i;
    
        pj=&j;
    
        i=5;
    
        j=7;
    
        cout<<"i = "<<i<<'\t'<<"j = "<<j<<'\n'<<"pi = "<<pi<<'\t'<<"pj = "<<pj<<endl;
    
        cout<<"&i = "<<&i<<'\t'<<"*&i = "<<*&i<<'\n'<<"&j = "<<&j<<'\t'<<"*&j = "<<*&j<<endl;
    
    
    }

修改后的程序为：

注：原代码无错误，仅输出格式不明确

输出结果：

![20190411195806500.png][]

(2) int main()   //C语言程序，要了解

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

int \*p,i;

p=a;    //将数组a首地址送给p

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

printf("%d,%d,%d,%d\\n",a\[i\],p\[i\],\*(p+i),\*(a+i));  //与cout功能差不多

运行结果：

1,1,1,1

2,2,2,2

3,3,3,3

通过这两道题目，希望学生掌握数组元素与指向数组的指针的不同。

a\[i\]表示数组中下标为i的元素。

a\[i\]←p\[i\]←\*(p+i)←\*(a+i)

a是数组名，表示数组首地址，(p+i)表示数组中第i个元素的地址，\*(p+i) 相当于a\[i\]。

(3)通过如下的问题理解递归函数的定义与调用（递归未讲，可以后做）

//\#include “stdio.h”

void f(char \*st,int i)

st\[i\]=’\\0’;

cout<<st;   // printf(“%s\\n”,st);

if (i>1) f(st,i-1);

void main()

char st\[\]=”abcd”;

f(st,4);

补充完整，运行时输出为\_\_\_\_\_\_\_\_

![2019041120002371.png][]

(4)下面程序的主函数中能保证p\[0\]输出1，p\[1\]输出2吗？如何修改以保证之（提示：在函数f中使用new生成动态数组；在main中用delete释放。）

#include<iostream>
    
    using namespace std;
    
    int *f()
    
    {
    
        int list[]={1,2,3,4};
    
        return list;
    
    }
    
    void main()
    
    {
    
        int *p=f();
    
        cout<<p[0]<<endl;
    
        cout<<p[1]<<endl;
    
    }

不能，建立new动态数组，修改后的代码如下：

#include<iostream>
    
    using namespace std;
    
    int *f()
    
    {
    
        int* list = new int[4];
    
        for(int i = 0 ,j = 1; i<4 ; i++,j++)
    
        list[i]=j;
    
        return list;
    
    }
    
    void main()
    
    {
    
        const int size=4;
    
        int list1[size];
    
        int* p=f();
    
        cout<<p[0]<<endl;
    
        cout<<p[1]<<endl;
    
        delete p;
    
    }

输出结果：

![2019041120024834.png][]

2、程序设计

(1)编写函数检查字符串s1是否为字符串s2的子串，若是，返回第一次匹配的下标，否则返回-1。在主程序中输入字符串s1与s2，调用函数实现。

函数原型：int indexof(const char \*s1,const char \*s2);

1. 流程图

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5NTY0NTU1_size_16_color_FFFFFF_t_70][]

2. 程序

#include<iostream>
    #include<cstring>
    using namespace std;
    
    int indexOf(char *s1, char *s2);
    
    int main()
    {
    	const int size=999;
    	char s1[size],s2[size];
    	cin.getline(s1,size);
    	cin.getline(s2,size);
    	indexOf(s1,s2);
    
    	return 0;
    }
    
    
    
    int indexOf(char *s1, char *s2)
    {
    	int a,b,index,j,k;
    	a=strlen(s1);
    	b=strlen(s2);
    	bool s3[a];
    	for(int m=0;m<a;m++)
    		s3[m]=false;
    	for(int i=0;i<b-a+1;i++)      //控制s2的首字母
    	{
    		for(j=0,k=i;(j<a)&&(k<i+a);j++,k++)      //控制s2的总输出数
    			if(s1[j]==s2[k])
    			{
    				index=i;
    				s3[j]=true;
    			}
    			int h=0;
    			for(int n=0;n<a;n++)
    			{
    				if(s3[n]==false&&i==b-a)
    				{
    					return -1;
    					break;
    				}
    				if(s3[n])
    					h++;
    			}
    			if(h==a)
    			{
    				cout<<index<<endl;
    				break;
    			}
    	}
    
    }

3. 结果

![20190411200830211.png][]

![20190411200838482.png][]

(2)编写一个函数将以字符串形式表示的一个16进制数转换为10进制数，并在主函数中测试。函数原型 int parseHex(const char \*const hexString);

如：调用函数 parseHex(“A5”);返回165

1. 流程图

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5NTY0NTU1_size_16_color_FFFFFF_t_70 1][]

2. 程序

#include<iostream>
    #include<cstring>
    #include<cmath>
    using namespace std;
    
    int parseHex(const char *const hexString);
    
    int main()
    {
    	int size=999;
    	char s[size];
    	cout<<"Please enter a number in hexChar : \n";
    	cin.getline(s,size);
    	cout<<"Tne number "<<s<<" in hexChar is "<<parseHex(s)<<" in decimal\n";
    
    	return 0;
    }
    
    int parseHex(const char *const hexString)
    {
    	int a,sum=0;
    	a=strlen(hexString);
    	int list[a];
    	for(int i=0;i<a;i++)
    	{
    		if(hexString[i]>='A'&&hexString[i]<='F')
    		  list[i]=(static_cast<int>(hexString[i])-55)*(pow(16,a-1-i));
        	else
    		  list[i]=(hexString[i]-48)*pow(16,a-i-1);
    		sum=sum+list[i];
    	}
    	return sum;
    }

3. 结果

![20190411201130540.png][]

![20190411201141234.png][]

（3）猴子吃桃：猴子第一天摘若干桃子，当即吃了一半，还不过瘾，又吃了一个。第二天又将剩下的桃子吃掉一半，又多吃一个，以后每天如此，到第10天，发现只剩最后一个桃子，问，第一天猴子共摘多少桃子（用递归实现）。

1. 流程图

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5NTY0NTU1_size_16_color_FFFFFF_t_70 2][]

2. 程序

#include<iostream>
    using namespace std;
    
    int main()
    {
    	int m=1;
    	for(int i=1;i<10;i++)
    		m=(m+1)*2;
    	cout<<"On the first day the monkey picked "<<m<<" peaches."<<endl;
    
    	return 0;
    }

3. 结果

![20190411201450716.png][]

（4）主程序中建立一动态数组（使用new），数组元素及元素个数由键盘输入，动态调试观察指针及指针指向的内容；设计一个函数对数组由小到大排序；主程序中用指针方式输出数组元素；最后释放数组内存（delete）。

1. 流程图

![20190411201724466.png][]

2. 程序

#include<iostream>
    using namespace std;
    
    void arrange(int p[],int size);
    
    int main()
    {
    	int size,a;
    	int* p=new int[size];
    	cin>>size;
    	for(int i=0;i<size;i++)
    		cin>>*(p+i);
    	cout<<"动态调试"<<endl<<"请输入你想要输出的数组"<<endl;
    	cin>>a;
    	cout<<"p["<<a-1<<"] = "<<*(p+a-1)<<endl;
    	arrange(p,size);
    	for(int b=0;b<size;b++)
    	    cout<<*(p+b)<<" ";
    	    cout<<endl;
    	delete p;
    	system("pause");
    	return 0;
    }
    
    void arrange(int p[],int size)
    {
    	int temp;
    	for(int n=0;n<size;n++)
        	for(int m=0;m<size-1;m++)
    	    	if(*(p+m)>*(p+m+1))
    	     	{
    		    	temp=*(p+m);
    		    	*(p+m)=*(p+m+1);
    		    	*(p+m+1)=temp;
    		    }
    }

3. 结果

![20190411201745467.png][]

[20190411195806500.png]: /images/20220221/bd89d449a7864fb2adb7aa61c5dbbdbd.png
[2019041120002371.png]: /images/20220221/86c676b7637a458cb9c92c51c6fde280.png
[2019041120024834.png]: /images/20220221/be6b95fb799541f5ac6c2e32d70f78d5.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5NTY0NTU1_size_16_color_FFFFFF_t_70]: /images/20220221/c8127a82d0b0422a936fd05289528d72.png
[20190411200830211.png]: /images/20220221/2dd071f7cad14993b83c4b2f5e8c4a7e.png
[20190411200838482.png]: /images/20220221/e9ece3bd0d244bf2aa2b28fde24c3db0.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5NTY0NTU1_size_16_color_FFFFFF_t_70 1]: /images/20220221/d971696ccb5a419aa77e90fe1968bd32.png
[20190411201130540.png]: /images/20220221/db59cdde2bce47fd8b074949ddae92af.png
[20190411201141234.png]: /images/20220221/bb256fc5c48e42b8b68617ee7d4d5bf7.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5NTY0NTU1_size_16_color_FFFFFF_t_70 2]: /images/20220221/ebd82f22445b4fa48c6a1875e5b9cf0e.png
[20190411201450716.png]: /images/20220221/5d8e34a4e91a4825a04ffb461260c5f5.png
[20190411201724466.png]: /images/20220221/de170253da024dfcad685cc31e069385.png
[20190411201745467.png]: /images/20220221/f2360bb8ee324d3a8fa3a2af3a89c5f4.png