您所在的位置:小祥子 » 编程 » IOS » 正文

【学习笔记】【C语言】指针

时间:2015-06-24 编辑:登山赏枫 来源:本站整理

一、指针变量的定义

1. 格式:变量类型 *指针变量名;
2. 举例:int *p;   char *p2;
3. 注意:定义变量时的*仅仅是指针变量的象征

二、利用指针变量简单修改其他变量的值

1.指向某个变量
int a;

int *p;
p = &a;
或者
int *p = &a;

2.修改所指向变量的值
*p = 10;

3.在函数内部修改外面变量的值
int a = 10;
change(&a);

void change(int *n)
{
    *n = 20;
}

三、指针与数组

1.将数组当做函数参数传入时,会自动转为指针

四、指针与字符串

1.定义字符串的2种方式
1> 利用数组
char name[] = "ios";
* 特点:字符串里面的字符是可以修改的
* 使用场合:字符串的内容需要经常修改

2> 利用指针
char *name = "ios";
* 特点:字符串其实是一个常量字符串,里面的字符是不能修改
* 使用场合:字符串的内容不需要修改,而且这个字符串经常使用

2.定义字符串数组
1> 利用二维字符数组
char names[2][10] = {"jack", "rose"};

2> 利用指针数组
char *names[2] = {"jack", "rose"};

五、代码

1.定义

 #include <stdio.h>
 
 void change(int);
 
 int main()
 {
     /*
     int a = 90;
     
     change(&a);
     
     printf("a=%d\n", a);
     */
     
     // 变量类型  变量名;
     // 格式:变量类型 *变量名;
     // 定义了一个指针变量p
     // 指针变量只能存储地址
     // 指针就一个作用:能够根据一个地址值,访问对应的存储空间
     // 指针变量p前面的int:指针变量p只能指向int类型的数据
     int *p;
     
     int a = 90;
     
     // 指针变量p指向了变量a
     p = &a;
     
     *p = 10;
 
     a = 20;
     
     printf("%d\n", *p);
     
     //printf("%d\n", a);
     
     return 0;
 }
 
 void change(int n)
 {
     n = 10;
 }

2.使用注意

 #include <stdio.h>
 
 int main()
 {
     /* 不建议的写法, int *p只能指向int类型的数据
     int *p;
     double d = 10.0;
     p = &d;*/
     
     /* 指针变量只能存储地址
     int *p;
     p = 200;
     */
     
     /* 指针变量未经过初始化,不要拿来间接访问其他存储空间
     int *p;
     printf("%d\n", *p);
     */
     
     int a = 10;
     /*
     int a;
     a = 10;
     */
     
     /*
     int *p;
     p = &a;
     */
     // 定义变量时的*仅仅是一个象征,没有其他特殊含义
     int *p = &a;
     
     // 不正确的写法
     // *p = &a;
     p = &a;
     
     // 这个时候的*的作用:访问指向变量p指向的存储空间
     *p = 20;
     
     
     char c = 'A';
     
     char *cp = &c;
     
     *cp = 'D';
     
     printf("%c\n", c);
     
     return 0;
 }

3.指向指针的指针

 #include <stdio.h>
 int main()
 {
     int a = 10;
     
     int *p = &a;
     
     int **pp = &p;
     
     // a = 20;
     
     // *p = 20;
     
     /*
     (*pp) == p
     
     *(*pp) == *p = a
     
     **pp == *p = a
     */
     **pp = 20;
     
     printf("%d\n", a);
     
     //int ***ppp = &pp;
     
     /*
     char a2 = 'A';
     char *p2 = &a2;
     */
     
     return 0;
 }

4.练习

 #include <stdio.h>
 void swap(int *v1, int *v2);
 
 int main()
 {
     /*
     int a = 10;
     int b = 11;
     
     swap(&a, &b);
     */
     
     
     int a2 = 90;
     int b2 = 89;
     
     swap(&a2, &b2);
     
     printf("a2=%d, b2=%d\n", a2, b2);
     return 0;
 }
 
 /* 不能交换外面实参的值,仅仅是交换了内部指针的指向
 void swap(int *v1, int *v2)
 {
     int *temp;
     temp = v1;
     v1 = v2;
     v2 = temp;
 }*/
 
 // 完成两个整型变量值的互换
 void swap(int *v1, int *v2)
 {
     int temp = *v1;
     *v1 = *v2;
     *v2 = temp;
 }
 
 /* 交换的只是内部v1、v2的值
 void swap(int v1, int v2)
 {
     int temp = v1;
     v1 = v2;
     v2 = temp;
 }*/
 #include <stdio.h>
 int sumAndMinus(int n1, int n2, int *n3);
 
 int main()
 {
     int a = 10;
     int b = 7;
     
     // 存储和
     int he;
     // 存储差
     int cha;
     c
     he = sumAndMinus(a, b, &cha);
     
     printf("和是%d, 差是%d\n", he, cha);
     
     return 0;
 }
 
 // 返回值是
 int sumAndMinus(int n1, int n2, int *n3)
 {
     *n3 = n1 - n2;
     
     return n1 + n2;
 }

5.指针和数组

 #include <stdio.h>
 
 /*
  1.数组元素的访问方式
  int ages[5];
  int *p;
  p = ages;
  1> 数组名[下标]  ages[i]
  2> 指针变量名[下标] p[i]
  3> *(p + i)
  
  2.指针变量+1,地址值究竟加多少,取决于指针的类型
   int *   4
   char *  1
   double * 8
  */
 void change(int array[]);
 
 int main()
 {
     // 20个字节
     int ages[5] = {10, 11, 19, 78, 67};
     
     change(ages);
     
     return 0;
 }
 
 // 利用一个指针来接收一个数组,指针变量array指向了数组的首元素
 void change(int *array)
 {
     printf("%d\n", array[2]);
     //printf("%d\n", *(array+2));
 }
 
 /*
 void change(int array[])
 {
     int s = sizeof(array);
     
     printf("%d\n", s);
 }*/
 
 void test()
 {
     double d = 10.8;
     double *dp;
     dp = &d;
     
     printf("dp = %p\n", dp);
     printf("dp + 1 = %p\n", dp + 1);
     
     int ages[5] = {10, 9, 8, 67, 56};
     
     int *p;
     // 指针变量p指向了数组的首元素
     p = &ages[0];
     // 数组名就是数组的地址,也是数组首元素的地址
     //p = ages;
     
     /*
      p ---> &ages[0]
      p + 1 ---> &ages[1]
      p + 2 ---> &ages[2]
      p + i ---> &ages[i]
      */
     
     //printf("%d\n",  *(p+2));
     
     printf("%d\n",  p[2]);
     
     /*
      for (int i = 0; i<5; i++) {
      printf("ages[%d] = %d\n", i, *(p+i));
      }*/
     
     
     //    printf("%p\n", p);
     //    printf("%p\n", p + 1);
     //    printf("%p\n", p + 2);
 }

6.指针和字符串

 #include <stdio.h>
 
 /*
  1.常量区
  存放一些常量字符串
  
  2.堆
  对象
  
  3.栈
  存放局部变量
  
  掌握:
  定义字符串的2种方式
  1> 利用数组
  char name[] = "itcast";
   * 特点:字符串里面的字符是可以修改的
   * 使用场合:字符串的内容需要经常修改
  
  2> 利用指针
   char *name = "itcast";
   * 特点:字符串其实是一个常量字符串,里面的字符是不能修改
   * 使用场合:字符串的内容不需要修改,而且这个字符串经常使用
  */
 
 int main()
 {
     char name[20];
     
     printf("请输入姓名:\n");
     
     scanf("%s", name);
     
     // 'j' 'a' 'c' 'k' '\0'
     
     //printf("%c\n", name[3]);
     
     //printf("刚才输入的字符串是:%s\n", name);
     
     return 0;
 }
 
 // 定义字符串数组
 void test2()
 {
     char *name = "jack";
     
     //int ages[5];
     
     // 指针数组(字符串数组)
     char *names[5] = {"jack", "rose", "jake"};
     
     // 二维字符数组(字符串数组)
     char names2[2][10] = {"jack", "rose"};
 }
 
 // 定义字符串
 void test()
 {
     // 字符串变量
     char name[] = "it";
     name[0] = 'T';
     
     //printf("%s\n", name);
     
     
     // "it" == 'i' + 't' + '\0'
     // 指针变量name2指向了字符串的首字符
     
     // 字符串常量
     char *name2 = "it";
     
     char *name3 = "it";
     
     //*name2 = 'T';
     
     //printf("%c\n", *name2);
     
     printf("%p\n%p\n", name2, name3);
     
     //printf("%s\n", name2);
 }
 #include <stdio.h>
 /*
  (不包括\0)
  编写一个int string_len(char *s),返回字符串s的字符长度
  
  */
 int string_len(char *s);
 
 int main()
 {
     //char *name = "itcast";
     
    // 男 \u434\u4343\u434
     
     int size = string_len("tre777");
     
     printf("%d\n", size);
     return 0;
 }
 
 int string_len(char *s)
 {
     // 1.定义一个新的指针变量指向首字符
     char *p = s;
     
     /*
     while ( *s != '\0' )
     {
         s++;
     }*/
     
     while ( *s++ ) ; 
     
     return s - p - 1;
 }
 
 /*
 int string_len(char *s)
 {
     // 记录字符的个数
     int count = 0;
     
     // 如果指针当前指向的字符不是'\0'
     // 首先*s取出指向的字符
     // 然后s++
     while ( *s++ )
     {
         // 个数+1
         count++;
         
         // 让指针指向下一个字符
         //s = s + 1;
         //s++;
     }
     
     return count;
 }
 */
 
 /*
 int string_len(char *s)
 {
     // 记录字符的个数
     int count = 0;
     
     // 如果指针当前指向的字符不是'\0'
     while ( *s != '\0')
     {
         // 个数+1
         count++;
         
         // 让指针指向下一个字符
         //s = s + 1;
         s++;
     }
     
     return count;
 }*/
关键词:学习 笔记