《charpointer》
字符指针
demo1.c
字符指针的初始化及赋值
#include <stdio.h>
int main(int argc, char *argv[])
{
char ch = 'A'; //字符变量
char * p;
p = &ch; //指针等于变量取地址
printf("%c %c\n", ch, *p);
return 0;
}
上下两个程序联合想明白，指针 1. 直接指向字符串
2. 指针指向字符数组
两种赋值方法需要注意的问题
demo2.c
字符数组初始化字符指针
#include <stdio.h>
#include <ctype.h>
int main(int argc, char *argv[])
{
char ch1[] = "hello World!"; //字符数组
char ch2[] = "hello World!"; // 两个字符串在内存中的不同位置
//同一个指针可以指向两个不同的字符串数组，且可以通过指针对字符串数组中的内容进行修改
char * p;
p = ch1;
//ch1[0]---*(ch1+0)----p[0], *p
if(isalpha(*p)) { // 判断字母
if (isupper(*p)) // 大写
*p = tolower(*p); // 转小写
else
*p = toupper(*p); //转大写
}
printf("%p %s\n", p, p);
p = ch2;
printf("%p %s\n",p, p);
return 0;
}
demo3.c
重要
#include <stdio.h>
#include <ctype.h>
int main(int argc, char *argv[])
{
char * p1 = "hello World!"; // 字符指针指向一个字符串常量，指针存储了字符串常量的起始地址，那么就不能通过指针去修改字符串中的内容，因为字符串的地址确定后不能改变（字符串实际放到了一个固定的区域，静态存储区，这个地方的值不能修改）
char * p2 = "hello World!";
*p1 -= 32; //不能这样使用，会出现段错误
printf("&p1=%p %p %s\n", &p1, p1, p1); // 不同的指针有自己的地址，但指向的是同一个地址 p1、p2是局部变量，存放在栈中，“全局变量，static修饰的局部变量，字符串常量”，三种情况数据存放在静态区，这个区域是程序结束时才释放内存，一旦分配后永远占据内存
printf("&p2=%p %p %s\n", &p2, p2, p2);
return 0;
}
demo4.c
解释的依然是上面程序中遇到的问题
#include <stdio.h>
#include <string.h>
int main(int argc, char *argv[])
{
char ch[50] = "welcome";
char * p1 = "hello World!";
strcpy(ch, p1);
// strcpy(p1, ch); // 错误 p1指针指向的是一个字符串，不能被改变
puts(ch);
puts(p1);
return 0;
}
demo5.c
不利用任何字符串函数，编程实现字符串连接函数功能 ( 重要 )
#include <stdio.h>
//#include <string.h>
int main(int argc, char *argv[])
{
char ch[100] = "welcome";
char * p = "hello World!", * q;
int i = 0;
q = p;
while (*(ch+i) != '\0')
i++;
while (*p != '\0') {
*(ch+i) = *p;
i++;
p++;
}
*(ch+i) = *p;
p = q;
puts(ch);
puts(p);
return 0;
}
先学习
《pointer》
指针的基本使用和理解
d1.c
#include <stdio.h>
int main(int argc, char *argv[])
{
int a = 10;
int * p;
int * q;
p = &a; //指针存放的是变量的地址
//q = &a;
q = p; //指针之间可以相互赋值
printf("&p:%p %d\n", &p, sizeof(p)); //指针所存放的字节数
printf("%p %p\n", p, &a);
printf("%d %d\n", a, *p); //*p 即变量 a 所指代的内容
printf("\n\n&q:%p %d\n", &q, sizeof(q)); // 变量 变量的地址 指针存储变量的地址 指针的地址 p 和 q 的地址不同，原因是变量不同，其分配的内存空间也不同，但p和q存储的数据相同--a地址
printf("%p %d\n", q, *q);
return 0;
}
d2.c
#include <stdio.h>
int main(int argc, char *argv[])
{
double a;
double * p;
p = &a;
printf("%d %d %p\n", sizeof(double), sizeof(p), p); // 指针所占字节数和电脑系统是32位还是64位有关系，32位，每个指针占4个字节
return 0;
}
d3.c
指针的运算
#include <stdio.h>
int main(int argc, char *argv[])
{
int a = 10, * p;
double b = 3, * q;
p = &a;
q = &b;
printf("%p %p\n", p, p+2); // +2越过2个数据，每个数据4个字节，那就是在首地址的基础上+8
printf("%p %p\n", q, q+2);
return 0;
}
d4.c
#include <stdio.h>
int main(int argc, char *argv[])
{
int a[5] = {4, 8, 1, 2, 7};
int *p, * q;
p = a; //&a[0];
q = &a[3];
printf("%p %p\n", p, q);
printf("%d %d\n", *p, *q);
printf("%d\n", q-p); //两个指针相减表示两指针之间相隔的数据的个数
return 0;
}
d5.c
指针++
#include <stdio.h>
int main(int argc, char *argv[])
{
int a[5] = {4, 8, 1, 2, 7};
int *p = NULL, *q; // 指针和 0 进行等于或不等于的关系运算，判断指针是否为空
printf("%d %p\n", p, p); // 0（nil）
p = a; //&a[0];
printf("%p %d\n", p, *p);
q = p++;
printf("%p %d\n",p, *p); //到这p已+1
printf("%p %d\n",q, *q);
return 0;
}
结果：
d6.c
第一次循环通过指针给数组赋值，给最后一个元素赋完值后，指针变量指到数组后的内存单元，此时已经超出了数组的大小限制，所以在第二次循环打印出的时候，需要重新 修正p = a;
#include <stdio.h>
#define N 5
int main(int argc, char *argv[])
{
int a[N];
int *p, i;
p = a;//int *p = a;
for (i = 0; i < N; i++)
scanf("%d", p++);//&a[i]
p = a;
for (i = 0; i < N; i++) {
printf("%d ", *p); //可以写为*p++ （++的优先级高于 * 的优先级）
p++;
}
puts("");
return 0;
}
d7.c
#include <stdio.h>
#define N 5
int main(int argc, char *argv[])
{
int a[N];
int *p, i;
p = a;//int *p = a;
for (i = 0; i < N; i++)
scanf("%d", p++);//&a[i]
p = a;
for (i = 0; i < N; i++) {
printf("%d ", *p++);
}
puts("");
return 0;
}
d8.c
数组和指针结合
指针指向数组的起始地址，数组是一串连续的空间，指针++就可以访问数组中每个元素的值
#include <stdio.h>
int main(int argc, char *argv[])
{
int a[] = {1, 6, 9, 12, 61, 12, 21};
int *p, i, n;
p = a;
n = sizeof(a) / sizeof(int);
printf("%p %p %p\n", a, a+1, a+2);
for (i = 0; i < n; i++)
printf("%d %d %d %d\n", a[i], *(p+i), *(a+i), p[i]); //四种等价方式的运用
puts(""); //输出换行符的方式
p++;
printf("%d\n", p[1]);//*(p+1)
return 0;
}
上面四种等价方式的直观图解
数组名也是一个地址，只不过是地址常量，其+1也可以实现地址移动
d9.c
将整形数组中n个数按反序存放
#include <stdio.h>
int main(int argc, char *argv[])
{
int a[] = {1, 6, 9, 12, 61, 12, 21};
int *p, *q, n, t;
n = sizeof(a) / sizeof(int);
p = a;
q = &a[n-1];
while (p < q) {
t = *p;
*p = *q;
*q = t;
p++;
q--;
}
for (t = 0; t < n; t++)
printf("%d ", a[t]);
puts("");
return 0;
}
d10.c
指针与二维数组
使用一级指针遍历二维数组
#include <stdio.h>
int main(int argc, char *argv[])
{
int a[3][2] = {{1, 6}, {9, 12}, {61, 12}};
int * p, i, n;
n = sizeof(a) / sizeof(int);
p = a[0]; //&a[0][0];
printf("%p %p\n", p, p+1); // 指针p+1 一次只加一个数据，但是（a+1）数组名+1，一次加的是一行的数据
printf("%p %p\n", a, a+1);
for (i = 0; i < n; i++)
printf("%d ", *(p+i)); // 二维数组遍历要使用两层循环，但使用指针，只需要一层 printf("%d\n",a[i][j]); 相同，注意四种通用的方法，即用数组的遍历方法，根据其和指针之间等价的表达关系，利用指针去遍历
puts("");
return 0;
}
d11.c
#include <stdio.h>
int main(int argc, char *argv[])
{
int a[3][2] = {{1, 6}, {9, 12}, {61, 12}};
int * p, i, n;
n = sizeof(a) / sizeof(int);
//a[1]++; 数组名是常量，不能做算数运算
//printf("%d\n", sizeof(a[1])); a[1]也代表的是数组名
p = a[0]; //&a[0][0];
printf("%p %p\n", p, p+1);
printf("%p %p\n", a, a+1);
for (i = 0; i < n; i++)
printf("%d ", *(p+i));
puts("");
return 0;
}
d12.c
#include <stdio.h>
int main(int argc, char *argv[])
{
int a[3][2] = {{1, 6}, {9, 12}, {61, 12}};
int * p, i, n;
n = sizeof(a) / sizeof(int);
printf("%p %p\n", a, a+1);
//printf("%p %p\n", a[0], a[0]+1); a[0]指二维数组中第一个一维数组名，a[0]+1 指一维数组a[0]中的下一个数据，这个地方可以解释上面一个程序图片中的内容，
// a[0] + 1 = *(a + 0) + 1;
printf("%p %p\n", *a, *a+1); // 等价 printf("%p %p\n", a[0], a[0]+1);
return 0;
}
d13.c
行指针
#include <stdio.h>
int main(int argc, char *argv[])
{
int a[3][2] = {{1, 6}, {9, 12}, {61, 12}};
int (*p)[2], i, j; //定义方式
p = a;
printf("%p %p\n", a, a+1);
printf("%p %p\n", p, p+1); //定义行指针这样表示，p+1 和 a+1 所移动的地址就是相同的
//printf("%d, %d, %d, %d\n", a[1][1], p[1][1], *(*(a + 1)+1), *(*(p + 1) + 1));
for (i = 0; i < 3; i++) {
for (j = 0; j < 2; j++)
printf("%d, %d, %d, %d ", a[i][j], p[i][j], *(*(a + i)+j), *(*(p + i) + j)); //不是很理解真正的用处在哪，感觉差不多
puts("");
}
return 0;
}
《指针二 parray》
指针数组
初始化
demo1.c
#include <stdio.h>
int main(int argc, char *argv[])
{
int * p[3];//int * -- p[0] p[1] p[2]
int a[] = {3, 6, 1, 9, 10};
p[0] = a;
p[1] = a + 1;
p[2] = a + 3;
printf("%d %d %d\n", a[0], a[1], a[3]);
printf("%d %d %d\n", *(p[0]), *(p[1]), *p[2]);
return 0;
}
demo2.c
指针数组常和二维数组结合使用
#include <stdio.h>
int main(int argc, char *argv[])
{
int a[2][3] = {{1, 4, 6}, {12, 9, 7}};//a----a[0] a[1]
int * p[2];
p[0] = a[0];//&a[0][0]
p[1] = a[1];//&a[1][0]
printf("%d\n", a[0][1]);
printf("%d\n", *(a[0]+1));
printf("%d\n", *(p[0]+1)); //上下两行是等价的表达方式
printf("%d\n", *(p[1]+2));
return 0;
}
demo3.c
#include <stdio.h>
int main(int argc, char *argv[])
{
int a[2][3] = {{1, 4, 6}, {12, 9, 7}};//a----a[0] a[1]
int * p[2] = {a[0], a[1]};
int i, j;
//printf("%p %p\n", p[0], a[0]);
//printf("%p %p\n", p[1], a[1]);
for (i = 0; i < 2; i++) {
for (j = 0; j < 3; j++)
//printf("%d %d ", *(a[i] + j), *(p[i]+j));
printf("%d %d ", *(*(a+i) + j), *(*(p +i)+j)); //这个地方和二维数组遍历是相同的，只不过使用了等价的表达方式
puts("");
}
return 0;
}
demo4.c
利用指针数组处理二维数组，要求求出二维数组所有元素的和
#include <stdio.h>
int main(int argc, char *argv[])
{
int a[2][3] = {{1, 4, 6}, {12, 9, 7}};//a----a[0] a[1]
int * p[2] = {a[0], a[1]};
int i, j, sum = 0;
int * * q;
q = p;//&p[0] //指针数组名是指针地址，一级指针取地址，相当于二级指针
printf("total:%d\n", sizeof(p)); //如何计算指针数组占用多少空间，指针的个数 * 指针占用的字节数
//指针数组名加1，移动多少字节？ 指针数组名 + 1就是移动了一个指针，即移动了一个指针所占用的字节数
//
//printf("%p %p\n", p[0], a[0]);
//printf("%p %p\n", p[1], a[1]);
for (i = 0; i < 2; i++) {
for (j = 0; j < 3; j++)
sum += *(p[i]+j);
//printf("%d %d ", *(a[i] + j), *(p[i]+j));
// printf("%d %d ", *(*(a+i) + j), *(*(p +i)+j));
//puts("");
}
printf("sum=%d\n", sum);
return 0;
}
《 pp 》
多级指针
二级指针
demo1.c
#include <stdio.h>
int main(int argc, char *argv[])
{
int m = 10;
int * p;
//.... * q;
int* * q;
p = &m;
q = &p;
printf("%p %p\n", p,&m);
printf("%p %p\n", q,&p);
printf("%d %d %d\n", m, *p, **q);
printf("%p %p\n", q, q + 1); //二级指针 + 1 就是移动一个一级指针，一个一级指针占4个字节
return 0;
}
demo2.c
多级指针和指针数组和二维数组结合到一起
#include <stdio.h>
int main(int argc, char *argv[])
{
int a[] = {3, 6, 9};
int * p[2] = {&a[0], &a[1]};//int * --- p[0] p[1]
int ** q;
q = &p[0];//p
q = p;
printf("%d %d\n", a[0], a[1]);
printf("%d %d\n", *p[0], *p[1]);
printf("%d %d %d\n", a[0], *p[0], **q);
printf("%d %d %d\n", a[1], *p[1], **(q+1)); //这个地方一级指针指向的是一维数组，所以指向它的二级指针 +1 移动的是一个元素，但如果其表示的是二维数组，那么+1 就代表经过了一行的元素
return 0;
}
demo1.c
利用二级指针输出字符串数组
#include <stdio.h>
int main(int argc, char *argv[])
{
//char * s1 = "apple";
//char * s2 = "pear";
char * s[] = {"apple", "pear", "potato"};
char ** p;
int i, n;
i = 0;
n = sizeof(s) / sizeof(char *);
p = &s[0];//p = s;
while (i < n){
printf("%s %s\n", s[i], *(p + i));
i++;
}
return 0;
}
《void_const》
const1.c
#include <stdio.h>
int main(int argc, char *argv[])
{
const int m = 10;
m++; // const 声明的变量值是常量的值，不能改变
return 0;
}
const2.c
const 修饰的两个位置需要注意的点
- 在 * 前，不能修改其目标的数值，但可以改变变量存储的地址值
- 在 * 后，不能修改指针的初始化地址值，但可以改变指针指向变量的数据值
#include <stdio.h>
int main(int argc, char *argv[])
{
int m = 10;
const int * p; // 使用const修饰指针，不能通过指针改目标的数值，但指针变量存储的地址值可以修改
int * const q = &m; //const 在 * 号后面，只能在定义时立即初始化，后续不可对该指针再次赋值
const int * const r = &m; //即地址值和数据值都不能改变
p = &m;//right; //地址可以改变
//(*p)++; error; //常量化指针目标是限制通过指针改变其目标的数值 ，但<指针变量>存储的地址值可以修改
//q = &m; error; 使得<指针变量>存储的地址值不能修改。但可以通过 *<指针变量名称> 可以修改指针所指向变量的数值
*q = 20;//right //指针指向变量的值可以改变
r++; //地址值不能改变
(*r)++ //数据值不能那个改变
return 0;
}
demo1.c
void指针
#include <stdio.h>
int main(int argc, char *argv[])
{
int m = 10;
double n = 3.14;
void * p, * q;
p = &m;//(void *)&m;
printf("%d %d\n", m, *(int *)p); //直接使用printf("%d ",*p); 由于 *p 是 void 指针类型，编译器无法以void 指针类型去取 m 整型变量的值，所以需要在使用void指针类型的时候，需要使用强制类型转换
printf("%p\n", p);
p++; // void指针在没有进行强制运算之前，不能进行运算
printf("%p\n", p);
q = &n;//(void *)&n;
printf("%.2lf %.2lf\n", n, *(double *)q);
printf("%p\n", p);
q++;
printf("%p\n", q);
return 0;
}
demo2.c
void指针访问一维数组
#include <stdio.h>
int main(int argc, char *argv[])
{
int a[] = {5, 9, 1, 6, 9, 10};
int i, n;
void * p; //使用不确定数据类型的void指针和确定数据类型的普通指针来对比，用法差不多，只不过最后输出的时候或进行运算的时候，需要进行强制类型转换
p = a;
n = sizeof(a) / sizeof(int);
for (i = 0; i < n; i++)
printf("%d ", *((int *)p + i));
puts("");
return 0;
}
demo3.c
#include <stdio.h>
int main(int argc, char *argv[])
{
int a[] = {5, 9, 1, 6, 9, 10};
int i, n;
void * q;
int * p;
q = a;
p = (int *)q; //void指针转换成普通指针的使用方法
n = sizeof(a) / sizeof(int);
for (i = 0; i < n; i++)
printf("%d ", *(p + i));
puts("");
return 0;
}
main.c
#include <stdio.h>
int main(int argc, const char * argv[]) {
//const char * argv[] = {"./a.out", "192.168.1.5", "9999"};
int i;
printf("argc=%d\n", argc);
for (i = 0; i < argc; i++) {
printf("%s\n", argv[i]);
}
return 0;
}
545
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
