指针基础 include <string.h>

//指针

//地址
//int a;
//&获取变量的地址 &a;

//int main(int argc, const char * argv[]) {
// int a;
// printf("%p ", &a);
// return 0;
//}

//*间接寻址符
//通过间接寻址符获取指定内存位置的值

//int main(int argc,const char *argv[])
//{
// int a=100;
// printf("%p ",&a);
//
// printf("%d ", *(&a));//
// printf("%d ", *((int *)0x7fff5fbff7bc));
// return 0;
//}

//指针变量: 本质是一个变量, 保存的是内存地址
//如: int *p; *说明是p是一个指针变量, int 说明指针指向的数据类型
//

//int main(int argc,const char *argv[])
//{
// int a=100;
// char ch='A';
// int *p = &a;
// char *q = &ch;
//
// printf("a = %d ", *p);
// p = 200;//p 整体是一个变量
// printf("a = %d ", *p);
//
// return 0;
//}

//指针变量占用的内存空间大小,与指向的数据类型没有关系
//跟具体的平台有关系,32位平台指针变量占用4字节内存空间
//64平台占用8字节内存空间
//128平台占用16字节内存空间

//int main(int argc,const char *argv[])
//{
// printf("%lu ", sizeof(int *));
// printf("%lu ", sizeof(char *));
// printf("%lu ", sizeof(long *));
// printf("%lu ", sizeof(double *));
//
// return 0;
//}

//指针变量的地址

//int main(int argc,const char *argv[])
//{
// int a=100;
// int *p = &a;
// printf("%p ", &a);
// printf("%p ", p);
// printf("%p ", &p);
//
// printf("%p ", *(&p));
//
// return 0;
//}

//指针变量的赋值

//int main(int argc,const char *argv[])
//{
// int a=100, b= 200;
// int *p;
// p = &a;
// int *q = &b;
// p = q;
//
// printf("%d ", *p);
// printf("%d ", *q);
//
// *p = 25;
//
// printf("%d ", *p);
// printf("%d ", *q);
// return 0;
//}

//void *p //泛型指针变量
//int * char *

//int main(int argc, const char *argv[])
//{
// int a=0xff05;
// float f = 3.14;
// void *p = &a;
// void *q = &f;
//
// printf("%x ", *(int *)p);
//
// *(int *)p = 200;
//
// printf("%d ", *((int *)p));
//
// printf("%.2f ", *(float *)q);
//
// return 0;
//}

//空指针 NULL
//#define NULL ((void *)0)

//int main(int argc,const char *argv[])
//{
// int *p=NULL;//防止野指针产生
// int a;
// p = &a;
// *p =200;//<==> a=200
// printf("a = %d ", a);
//
// return 0;
//}

//1.定义了指针变量,没有赋初值,直接使用
//2.指针指向的内存释放后,指针变量没有赋值为NULL;
//#include <stdlib.h>
//
//int main(int argc,const char *argv[])
//{
// char *p = (char )malloc(100sizeof(char));
// scanf("%s", p);
// printf("%s ", p);
// free(p);
// p = NULL;
// return 0;
//}

//指针运算

//指针变量自增自减,每次跳过指针变量指向的数据类型大小个字节

//int main(int argc,const char *argv[])
//{
// int a[10]={1,2,3,4,5,6,7,8,9,10};
// int *p = a;
// char str[100]="helloWorld";
// char *pstr = str;
//
// for (int i=0; i<10; i++) {
// printf("%d ", *p);
// p++;
// }
//
// p--;
// printf("%d ", *p);
//
//// printf("%d ", *p);
//// printf("%p ", p);
//// p++;
//// printf("%p ", p);
//// printf("%d ", *p);
////
//
//
//
//
//
//// printf("%p ", pstr);
//// pstr++;
//// printf("%p ", pstr);
//
//
// return 0;
//}

//指针的减法运算
//指针变量不能进行加法运算
//int main(int argc,const char *argv[])
//{
// int a[10]={1,2,3,4,5,6,7,8,9,10};
// int *p = &a[0];
// int *q = &a[5];
//
// printf("p = %p ", p);
// printf("q = %p ", q);
// printf("%ld ", q-p);//(q - p)/sizeof(int)
//
//
// return 0;
//}

//指针比较大小
//int main(int argc,const char *argv[])
//{
// int a,b;
// int *p= &a;
// int *q= &b;
//
// if (p>q) {
// printf("a变量的内存位置高于b ");
// }
// else
// {
// printf("b变量的内存位置高于a ");
// }
// return 0;
//}

void swap(int *a, int *b)
{
int temp = *a;
*a = *b;
*b = temp;
}

int main(int argc,const char *argv[])
{
int m=10,n=20;
int *pm = &m;
int *pn = &n;

swap(&m, &n);
printf("m = %d n= %d
", m, n);

return 0;

}
//指针与函数
//利用指针,输入10个数到数组中, 再输出

void printArr(int *a, int len)
{
for (int i=0; i<len; i++) {
printf("%d ", *a);
a++;
}
printf(" ");
}

//int main(int argc, const char *argv[]) {
// int a[10];
// for (int i=0; i<10; i++) {
// scanf("%d", &a[i]);
// }
// printArr(a, 10);
// return 0;
//}

//1 2 3 4 5
//src + 1
//src + i;

void reverseArr(int *src, int len)
{
for (int i=0; i<len/2; i++) {
// int temp = src[i];
// src[i]=src[len-i-1];
// src[len-i-1]=temp;
int temp = *(src+i);
(src+i)=(src+len-i-1);
*(src+len-i-1)=temp;
}
}

//int main(int argc,const char *argv[])
//{
// int a[5]={1,2,3,4,5};
// reverseArr(a, 5);
// printArr(a, 5);
//
// return 0;
//}

//练习:编写函数 replace, 在一个字符数组里面查找指定字符,并用相应的字符替代。函数原型如下:
//"helloWorld"
//'o' --> 'A'
//"hellAWArld";
// h e l l o
//src=&h
//src+1
char * replace(char src, char old, char new, int length)
{
for (int i=0; i<length; i++) {
// if(src[i]==old)
// {
// src[i]=new;
// }
if ((src+i)==old) {
*(src+i)=new;
}
}
return src;
}
//int main(int argc,const char *argv[])
//{
// char str[]="helloworld";
// replace(str, 'l', 'A', 10);
// printf("%s ", str);
//
// return 0;
//}

//练习:编写函数 insert, 向一个字符数组指定位置插入一个字符,后面的字符依次向后移动。函数原型如下:
//void insert(char *src, int index, char new, int length)
//"helloworld"
//'A' 5
//"helloAworld"

void insert(char *src, int index, char new, int length)
{
for (int i=length-1; i>=index; i--) {
*(src+i+1) = *(src+i);
}
*(src+index) = new;
}
//int main(int argc,const char *argv[])
//{
// char str[100]="helloworld";
// insert(str, 5, 'A', 10);
// printf("%s ", str) ;
// return 0;
//}

//指向常量的指针
//const
//保护,只读

//const type a
//type const a

int main(int argc,const char *argv[])
{
// int const a=10;
// const int a=10;//变量a不可以被修改
// printf("a = %d ", a);

// int b=15;
// int c=20;
// const int *p= &b;// p只读, p可以被修改
// //p = 30;
// p = &c;

// int a=30;
// int b=20;
// const int const p = &a;//p 只读 p只读

// int a=34;
// int b=45;
// int * const p = &a;//*p 可以被修改, p只读
// *p = 50;
// printf("%d ", a);

//int const *p1,p2;//p2是int型变量 p1是int *型变量
//p2不可被修改 p1 可以被修改, *p1不可以被修改

// int a;
// int const p1,p2;
// //p1 可以被修改, *p1不可以被修改, *p2不可以被修改,p2可以被修改
// p2 = &a;

// int a;
// int const *const p1, p2;//p1 p1 *p2不可以被修改,p2可以被修改
// p2 = &a;
// //p1 = &a;

// int a;
// int const p1,p2;//p1不能被修改, p1,p2,p2能被修改

int *const p1,*const p2;//p1 p2不能被修改, *p1,*p2可以被修改
return 0;

}

指针基础 include

相关推荐