学习C语言 8.7 指针操作数组

于 2024-08-08 00:13:33 发布
阅读量773 收藏 22
点赞数 29
文章标签： 学习 c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Ld1626162003/article/details/141000421
版权

目录

一、指针操作一维字符型数组 

1.定义指针

2.指针 + 字符串 

一、指针操作一维字符型数组 

1.定义指针

char s[] = "hello"';

char *p=&a[0];

char *p = s; //数组名的值就是首元素的地址

2.指针 + 字符串 

字符串 // 在c语言中是按照字符数组的形式存储
            // 字符串常量 --- 存储在字符串常量区 
       
处理字符串:
   char s[] = "hello"; //表示 在栈上开辟一块空间，用字符串常量中的 "hello"进行初始化 
                        
   const char *p = "hello"; //表示 p指向了 字符串常量区中的 "hello"
                                       //因为 是指向了字符串常量区 ，所以只能做读取操作，不能修改

3.const 关键字

const //表示只读  

const int a; //a 此时是一个只读的变量

const int *p = &a;   //const限定是 基类型 
                     //表示不能通过 *p 的方式 修改基类型数据 
                     
int const *p = &a;   //const限定是 基类型 
                     //表示不能通过 *p 的方式 修改基类型数据 

                     
int * const p = &a; //const限定是 指针变量p 
                    //表示将p限定位只读 
                    //表示p不能被修改 
                    
const int * const p = &a;  //基类型和指针变量 都被限定为只读
                           // p = &b; //不能修改 
                           //*p = b;  //不能修改

原则:
   就近原则  //const 离谁近 就限定谁  
应用:
    1.如果 不想 通过*p方式改变基类型对应的数据 
      const int *p = &a;  
      int const *p = &a;  
    2.如果 指针变量p 定义好后，不想再指向别的变量 
      则 
        int * const p = &a;
                     

在函数中形参设计为 const char *
    目的：防止函数中的误操作 
    好处：
    (1).提前发现问题 
        将运行时才出现的问题，提前到编译时  
    (2).const char *
        可以接收（可以将可读可写的传给只读的，但不能反过来，否则会使得权限扩大） 
        char *
        const char *

       实参:
         可以 数组名 
         可以 指针变量  char *p //const char *p         
         可以 直接是一个字符串常量 
        提高参数的适用性 
        
    所以能写成const的 都写const。

gets函数，通过指针形式

#include <stdio.h>

char * mygets(char *s)
{
	char *ret = s;
	scanf("%c",s);
	while(*s!='\n')
	{
		scanf("%c",++s);
	}
	*s='\0';
	return  ret;
}


int main(void)
{
	char b[100];
	mygets(b);
	puts(b);

	return 0;
}

puts函数，通过指针形式

#include <stdio.h>

int myputs(const char *s)
{
	if(s==NULL)
	{
		return -1;
	}
	while(*s != '\0')
	{
		putchar(*s++);
	}
	putchar('\0');

	return 0;
}

int main(void)
{
	char a[]="hello";
	char *p=a;
	//char *p=&a[0];

	const char *q="world";

	myputs(p);
	myputs(a);
	myputs(q);
	myputs("well");

	return 0;

}

指向栈上的的指针，指向字符串常量区的指针，数组名，和字符串常量都可以输出。

strlen函数，通过指针形式

#include <stdio.h>

size_t mystrlen(const char *s)
{
	int i=0;
	while(*s!='\0')
	{
		++s;
		++i;
	}
	return i;
}

int main(void)
{
	char a[]="hello";
	puts(a);
	printf("%ld\n",mystrlen(a));

	return 0;
}

strcpy函数，strncpy函数通过指针形式

char src[] = "hello"
strncpy(dest,src,8);

    char *Strncpy(char *dest, const char *src, size_t n)
    {
        //1.始终拷贝了n下 
        
        //1. 拷贝 
            '\0' && n 
        //2. 考虑n 
             n有没有结束 
             完成剩余的次数的拷贝 
             剩余的拷贝过去的数据是 '\0'
    }

#include <stdio.h>

char * mystrcpy(char *dest,const char *src)
{
	char *ret=dest;
	while(*src!='\0')
	{
		*dest=*src;
		dest++;
		src++;
	}
	*dest='\0';

	return ret;
}

char * mystrncpy(char *dest,const char *src,size_t n)
{
	char *ret=dest;
	int i=0;
	while(*src!='\0' && i!=n )
	{
		*dest=*src;
		dest++;
		src++;
		i++;
	}
	if(i<n)
	{
		int j=0;
		for(j=0;j<(n-i);++j)
		{
			*dest='\0';
			dest++;
		}
	}
	return ret;
}

int main(void)
{
	char a[100]="helloworld";
	char b[100]={1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1};

	puts(a);
	mystrncpy(b,a,15);
	puts(b);

	int i=0;
	for(i=0;i<20;++i)
	{
		printf("b[%d]%c %d\n",i,b[i],b[i]);
	}
	return 0;
}

strcat函数，strncat函数通过指针形式

char *strcat(char *dest, const char *src)
{
  //1.定位 dest的 '\0'
  //2.拷贝 
    直到src到达'\0'
}

char src[] = "hello";

strncat(dest,src,3);
char *Strncat(char *dest, const char *src, size_t n)
{
   //1.可以指定 n 
   //如果 src 长度 > n  
    就将前n个字符拼接过去 
   //如果 src 长度 < n
    直接将src字符串拼接过去
    
   最终 一定要保证 dest是一个字符串 '\0'

}

#include <stdio.h>

char * mystrcat(char *dest,const char *src)
{
	char *ret=dest;
	while(*dest!='\0')
	{
		dest++;
	}
	while(*src!='\0')
	{
		*dest=*src;
		dest++;
		src++;
	}
	*dest='\0';

	return ret;
}

char * mystrncat(char *dest,const char *src,size_t n)
{
	char *ret=dest;
	while(*dest!='\0')
	{
		dest++;
	}
	while(*src!='\0'&&n!=0)
	{
		*dest=*src;
		dest++;
		src++;
		n--;
	}
	*dest='\0';

	return ret;
}

int main(void)
{
	char a[100]={'h','e','l','l','o','\0',1,1,1,1,1,1,1,1,1,1,1,1};
	char b[100]="world";

	mystrncat(a,b,3);
	puts(a);
	
	int i=0;
	for(i=0;i<20;++i)
	{
		printf("a[%d]%c %d\n",i,a[i],a[i]);
	}

strcmp函数，strncmp函数通过指针形式

#include <stdio.h>

int mystrcmp(const char *s1,const char *s2)
{
	while(*s1==*s2 && *s1!='\0' && *s2!='\0')
	{
		s1++;
		s2++;
	}
	return *s1-*s2;
}

int mystrncmp(const char *s1,const char *s2,size_t n)
{
	while(*s1==*s2 && *s1!='\0' && *s2!='\0'&& n>1)
	{
		s1++;
		s2++;
		n--;
	}
	return *s1-*s2;
}
int main(void)
{
	char a[100]="hello";
	char b[100]="help";

	puts(a);
	puts(b);

	int ret = mystrncmp(a,b,3);
	
	printf("%d\n",ret);
	

	return 0;
}

n减到0的时候，两个字符串最后停位置是在后一个，所以条件是n>1而不是n不为0。

以上函数的返回值有些是如char *的指针类型，这是为了进行链式操作

eg： char s1[10];
        char s2[10];

strcpy(s2,strcpy(s1,"hello"));//链式操作 

strcpy只能拷贝字符串，而memcpy可以拷贝任意类型的数据，只要有地址。但要注意不同类型之间拷贝的话，可能会出现数据覆盖。

void *memcpy(void *dest, const void *src, size_t n)
 {
      //一个字节一个字节拷贝（char类型刚好是一个字节） 
 }

 
 void * //NULL 空指针 
        //空类型的指针 --- 万能指针
        //可以接收任意类型的指针
        
注意:如果用空类型指针进行间接运算必须转换成有明确类型的指针 

#include <stdio.h>
#include <string.h>

void * mymemcpy(void *dest, const void *src, size_t n)
{
	char *p=dest;
	const char *q=src;
	int i=0;
	for(i=0;i<n;++i)
	{
		*p=*q;
		p++;
		q++;
	}
	return p;
}

int main(void)
{
	long a[5]={1,2,3,4,5};
	long b[5];

	mymemcpy(b,a,5*sizeof(a[0]));

	int i=0;
	for(i=0;i<5;++i)
	{
		printf("%ld\n",b[i]);
	}

	return 0;
}

二、指针操作二维数组 

int a[2][3];

//二维数组 
        c语言中并不存在，真正的二维数组。
        二维数组本质 是一维数组的一维数组 
        二维数组 也 符合数组的特点 //连续性，有序性，单一性 

//从二维数组的本质出发 
int[3] a[2]; 

1.定义指针

    //a[0]  --- int[3]
    //&a[0] --- int[3] * 
    //c语言中 不支持 int[3] *  
    //正确写法 int(*)[3]

int(*p)[3] = a; //p指向二维数组 a 
                //p的基类型 int[3]

2.访问数组中的元素

*p <=> a[0] // 相当于是内部这个一维数组的数组名 
 a[0][0] <=> (*p)[0] //一维数组的元素是通过*(p+i)访问的
                    *(*(p+0)+0) //**p

*(*(p+1)+1) <=> a[1][1]
*(*(p+i)+j) <=> a[i][j]       

   二维数组的本质 一维数组的 一维数组

Ld1626162003
关注
C语言程序设计（第4版）谭浩强著—学习笔记chapter eight 指针
m0_63640882的博客
04-12 580
第八章 指针一、指针（地址）与指针变量二、通过指针引用数组三、通过指针引用字符串 内存区的每一个字节有一个编号，这就是地址。如果程序中定义了一个变量，在对程序进行编译时，系统就会给这个变量分配内存单元。 C语言中， 对变量的访问有两种方式，直接访问和间接访问。 int a=5;//直接访问 scanf(“%d”,&a);//间接访问 C语言中，指针是存放地址的一种特殊变量。也可以把该变量的地址称为指针。 在C语言中可以定义一些特殊变量，将这些专门存放变量的地址的特殊变量称为指针变量。 指针变量的值是
C和指针 第8章 数组 8.7 问题
weixin_客子光阴的博客
06-20 488
C和指针 第8章 数组 8.7 问题
2. 使用指针操作数组
u014464353的专栏
05-12 469
2. 使用指针操作数组 2.1 可以使用数组名作为数组第一个元素的指针。 2.2 实例 #include void test_pointer1(){             int a[] = {1,2,3,4};             // a 表示数组第一个元素的地址             printf("a=%p\n",a);             int *p =
C语言指针操作
qq_42544728的博客
08-13 273
可以对指针进行哪些操作？C提供了一些基本的指针操作，下面的程序实例给出了8种不同的操作，为了显示操作的结果，该程序提供了指针的数值（即所谓指向指针的地址），若编译器不支持%p转换说明，可以用%u或者%lu代替。 #include<stdio.h> int main(void) { int urn[5] = { 100,200,300,400,500 }; int * ptr1, *ptr2, *ptr3; ptr1 = urn; ptr2 = &urn[2]; printf
嵌入式学习笔记十四——指针操作一维字符型数组
最新发布
haobe的博客
08-07 657
1.形参设计为 const char *的目的， 防止函数中的误操作2.好处(1).提前发现问题 将运行时问题，提前到编译时(2).const char * 可以接收 char *和const char * 提高参数的适用性注意:形参能写成const的都写const1.指针操作一维字符型数组 //字符串2.知识点//1.指针变量的 类型 是怎么确定的?//2.一维字符型数组 字符串//3.处理字符串数据方式//4. const 关键字const 关键字使用方法。
C语言指针操作详细过程
FML7169的博客
03-23 703
C语言指针操作主要分为三步 第一步 : 所有变量都保存在内存中，我们打印一下变量的存储地址 第二步：所有变量都可以保存某些值,接着赋值并打印*/ 第三步：使用指针：1取值 2 举例说明： void test() { int a; int *p; char *t; /*第一步 : 所有变量都保存在内存中，我们打印一下变量的存储地址*/ ...
C语言指针的基本用法
qq_51323107的博客
10-31 5087
c语言数组的用法
数组和指针练习题目（精选）
12-23
在C语言中，数组的名称实际上是一个指向数组首元素的指针。例如，`int a[5];` 就定义了一个整型数组 `a`，其名称 `a` 就是一个指向数组首元素的指针。 选择题 [8.1] 若有定义：`int x,*pb;` 则在以下正确的赋值...
C语言程序设计第8章善于利用指针.pptx
11-15
本章节主要介绍了指针的概念、指针变量的定义和使用、指针的引用、通过指针引用数组和字符串、返回指针值的函数、指针数组和多重指针、动态内存分配与指向它的指针变量等内容。 8.1 指针是什么 指针是内存单元的...
从零开始学习C语言
qq_43708708的博客
04-09 2622
该文章提供了C语言学习的基础知识和技巧，包括数据类型、变量、控制流、数组、函数等内容。通过清晰的解释和示例，帮助初学者建立起对C语言编程的理解和技能。
C语言指针操作·八大总结
醉蕤的博客
09-01 1093
C语言指针操作·八大总结
C语言——指针（入门详解）
sinzz的博客
11-27 7772
C语言——指针（入门版详解）
C语言之指针详解
热门推荐
上善若泪
10-30 2万+
当初学C语言，指针是最头疼的地方，难以理解，不过时间长了就自然明白了通过指针，可以简化一些 C 编程任务的执行，还有一些任务，如动态内存分配，没有指针是无法执行的。每一个变量都有一个内存位置，每一个内存位置都定义了可使用&运算符访问的地址，它表示了在内存中的一个地址。用register修饰的变量是没法取到地址的，没有内存位置int * p;// 定义指针变量 p = & var_runoob;printf("var_runoob 变量的地址： %p\n" , p);return 0;
C语言指针详解
weixin_61486281的博客
10-19 1943
指针是C语言的重要特点，正是由于指针的存在，C语言才能完成各种对内存的操作。那么，什么是指针呢？内存被划分成一个个内存单元，每个内存单元的大小是1字节，为了实现对内存的操作，每一个内存单元都有一个编号，就想楼栋的门牌号一样，称为地址。。通过&取出变量的地址赋给指针变量；通过解引用操作符（*）找到指针所指向的内存。
C语言指针·入门用法超详解
时光の尘的博客
07-31 1170
通过内存地址，指向的空间，我们可以对空间的数据进行修改，而这个内存地址就被称为指针。在代码当中，我们会拿一个变量将指针进行存起来，那么这个变量就叫做指针变量。通常情况下，我们会将指针变量，称为指针，但我们需要了解，真正的指针，实际上是指针变量存起来的内存地址。指针变量起始就是存着指针的变量，本身也是变量，而我们变量的定义格式是：数据类型 变量名；
C语言之指针篇【超详细讲解，带你层层深入理解指针】
一名还在努力学习技术的程序员的博客
06-10 2万+
本篇博客详细讲解了指针部分的内容
指针和数组（操作详解）
weixin_46272577的博客
05-08 1149
文章目录指针和数组数组概述一维数组二维数组指针表示法和数组数组和指针的差别用malloc创建一维数组用realloc调整数组长度传递一维数组数组表示法指针表示法使用指针的一维数组声明一个整数指针的数组指针和多维数组传递多维数组动态分配二维数组分配可能不连续的内存分配连续内存 指针和数组 本文基本为深入理解指针的笔记 数组概述 不要混淆二维数组和指针数组，它们类似但是行为会有差异 一维数组 int vector[5] = { 1,2,3,4,5 }; 数组索引从0开始，到声明长度减一结束 无效的索引访
C语言的指针
把酒送清风的博客
10-24 2692
指针（pointer）是C语言最重要的（有时也是最复杂的）概念之一，是一个值为内存地址的变量，用于存储变量的地址。指针的第一个基本用法就是在函数间传递信息。概括地的说，如果主调函数不使用return返回的值，则必须通过地址才能改变主调函数（Main函数）中的变量值。
C语言指针详解：通过指针操作数组
此外，第8章还涵盖了其他指针相关的主题，如指向函数的指针（8.5节），返回指针值的函数（8.6节），指针数组和多重指针（8.7节），以及动态内存分配与指向它的指针变量（8.8节）。最后，8.9节对指针的相关知识进行了...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值