C语言回顾之进制、内存分析与指针

一、指针前奏
1、指针的重要性
指针是C语言中非常重要的数据类型，如果你说C语言中除了指针，其他你都学得很好，那你干脆说没学过C语言。
2、小需求
void change(int  n)函数调用完毕后，改变实参的值
分析：修改实参的值->找到存储空间->地址

二、指针变量的定义
1、定义的格式
类名标识符  *指针变量名;
例如：int *p;
2、先定义后赋值
简单取值

	int a = 10;
	int *p;
	p = &a;
	printf(“%d”, *p);

简单改值

p = 9;

3、定义的同时赋值

int a = 10;
int *p = &a;

4\实现修改实参

void change(int *p)
{
  *p = 10;
}

int main()
{
  int a =20;
  change(&a);
}

5、注意点
（1）int *p;   p = 1000; 错误：p存放的是地址
（2）int *p;   *p = 100; 错误：不知100的地址
（3）int *p;  *p = &a; 错误：这种写法*p指向的是值是a的地址
（4）%p输出指针里面存储的地址值
（5）其他指针类型说明，比如float *p;  char *p;
（6）不能乱用类型，比如int a = 10;  float *p = &a;
6、清空指针
（1）p = 0;
（2）p = NULL;

三、指针实例 
1.void swap(char *a, char *b)  （注意temp=a;  a = b; b = temp;）

void swap(char **a,char **b)
{
    char *p;
    p = *a;
    *a = *b;
    *b = p;
}
int main()
{
    char *a = "10";
    char *b = "11";


    swap(&a, &b);
    printf("a=%s,b=%s",a,b);
    return 0;
}

2.int sumAndMinus(int a, int b, int *minus)

int sumAndMinus(int a,int b,int *minus)
{
  *minus = a-b;
  return a+b;
}

四、指针探究
1.指针变量所占用4个字节的存储空间
2.为何指针变量要分类型？

声明指针时，指针类型决定指针移动的单位距离，也就是移动多少字节的内存空间的地址

例如：

char *pc,  str[]="12345";
double *pd, num[]={1,2,3,4,5};
pc = str;
pd = num;

其中pc++，指针指向下1个字节的内存空间的地址。 pd++，指针指向下8个字节的内存空间的地址。

如果定义了如下代码

int i = 2;
char c = 1;
int *p = &c;
printf(“%d”, *p);

那么打印出来的数据将会是错误的

代码示例

#include<iostream>
//函数声明
void change( int *p);
void heandcha(int a,int b,int *he,int *cha);
int main(){
     //定义一个int类型的指针变量，只能用来存储地址，这个*是一个象征，象征着定义了一个指针变量p
     int *p;
     int a = 10;
     //取得变量a的内存地址,并把地址赋值给指针变量p
     p=&a;
     //把10赋值给p指向的内存地址 ，这个*的作用就是去访问p的存储空间
     *p=10;
     printf("%d",a);

     a = 20;
     // *p访问指针变量所指向的存储空间
     printf("%d",*p);

     change(p);

     printf("%d",a);

     /**定义一个函数，返回两个变量的和和差*/
     int w=10;
     int j=20;
     int he;
     int cha;
     heandcha(j,w, &he,&cha);
     printf("====和是%d，差是%d",he,cha);
     return 0;
}

void change( int *p){
     *p=30;
}

//传如内存地址参数，直接修改内存中的值，实现返回两个结果的效果
void heandcha(int a,int b,int *he,int *cha){
     *he=a+b;
     *cha=a-b;

}

五、指针与数组
1、指向一维数组元素的指针

int array[] = {1,2,3,4,5};
int *p = array;

2、用指针遍历一维数组元素

    for (; *p!='\0'; p++) {
        printf("%d",*p);
    }

3、*(p+i)和*(p++)的区别  如果为int类型的指针+1实际就是+4个字节

六、指针与字符串
1、字符串回顾
char s[] = “cx”;
2、其他定义字符串的方式
char *s = “wj”;
或者
char *s;
s = “wj”;

#include <stdio.h>
/*
(不包括\0)
编写一个int string_len(char *s)，返回字符串s的字符长度

*/
int string_len(char *s);

int main()
{
    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'
    while ( *s != '\0')
    {
        // 个数+1
        count++;
       
        // 让指针指向下一个字符
        //s = s + 1;
        s++;
    }
   
    return count;
}*/

七、返回指针的函数
指针也是C语言中的一种数据类型，因此一个函数的返回值肯定可以是指针类型的
返回指针的函数的一般形式为：类型名 * 函数名(参数列表)

例如：

int main()
{
    char *name = test();
    
    printf("name=%s\n", name);
    
    return 0;
}

char *test()
{
    return "rose";
}

八、指向函数的指针
1、为什么指针可以指向一个函数？
函数作为一段程序，在内存中也要占据部分存储空间，它也有一个起始地址，即函数的入口地址。函数有自己的地址，那就好办了，我们的指针变量就是用来存储地址的。因此，可以利用一个指针指向一个函数。其中，函数名就代表着函数的地址。
2、指向函数的指针的定义
定义的一般形式：函数的返回值类型 (*指针变量名)(形参1, 形参2, ...);
3、使用注意
由于这类指针变量存储的是一个函数的入口地址，所以对它们作加减运算(比如p++)是无意义的
指向函数的指针变量主要有两个用途：调用函数和将函数作为参数在函数间传递

#include <stdio.h>
char *test();

int main()
{
    char *name = test();
   
    printf("name=%s\n", name);
   
    return 0;
}

char *test()
{
    return "rose";

}

九、用指针调用函数
1、定义指向函数的指针

例如有函数

int sum(int a,int b)

{

return a+b;

}

那么就可以有
   int (*p)(int,int);
    p = sum;
    或者
   int (*p)(int, int) = sum;
3.如何间接调用函数
（1） p(10.7, "jack", 10);
（2） (*p)(10.7, "jack", 10);

void test()
{
    printf("调用了test函数\n");
}

int sum(int a, int b)
{
    return a + b;
}

int main()
{
    // 定义指针变量指向sum函数
    // 左边的int：指针变量p指向的函数返回int类型的数据
    // 右边的(int, int)：指针变量p指向的函数有2个int类型的形参
    int (*p)(int, int);
   
    p = sum;
   
    //int c = p(10, 11);
   
    //int c = (*p)(10, 11);
   
    int c = sum(10, 9);
   
    printf("c is %d\n", c);
// (*p)是固定写法，代表指针变量p将来肯定是指向函数</span>
// 左边的void：指针变量p指向的函数没有返回值</span>
// 右边的()：指针变量p指向的函数没有形参</span>
    void (*p)();</span>

    // 指针变量p指向了test函数
    p = test;</span>

    p();
    //(*p)(); // 利用指针变量间接调用函数
    //test(); // 直接调用函数
   
    return 0;
}

十、进制

1、什么是进制
进制是一种计数的方式，数值的表示形式

11用各种进制来表示有：   十进制：11  二进制：1011  八进制：13 

多种进制：十进制、二进制、八进制、十六进制。也就是说，同一个整数，我们至少有4种表示方式
2、二进制
（1）特点：只有0和1，逢2进1
（2）书写格式：0b或者0b开头
（3）使用场合：二进制指令\二进制文件，变量在内存中就是二进制存储
（4）二进制和十进制的互相转换
（5）n为二进制位所能表示的数据范围（不考虑负数）：0~2的n次方-1

3、八进制
（1）特点：0~7，逢八进一
（2）书写格式：0开头
（3）八进制和二进制的互相转换

4、十六进制
（1）特点：0~F，逢十六进一
（2）书写格式：0x或者0X开头
（3）十六进制和二进制的互相转换

5、总结
printf以不同进制形式进行输出

十一、变量的内存分析
1、字节和地址
为了更好地理解变量在内存中的存储细节，先来认识一下内存中的“字节”和“地址”。
（1）内存以“字节为单位”

（2）不同类型占用的字节是不一样的

2、变量的存储
（1）所占用字节数跟类型有关，也跟编译器环境有关

（2）变量实例
int b = 10;
int a = 134;
（2）内存由大到小寻址
（3）只存储二进制形式
（4）每个变量都有地址：第一个字节的地址就是变量的地址

（5）查看内存地址的两种方式：%x和%p
（6）查看整数的二进制形式的两种方式

//输出整数的二进制形式
void printBinary(int a){
     for(int i = 31;i>=0;i--){
          printf("%d",a>>i&1);
          if(i%4==0){
               printf("     ");
          }            
     }
}
void printBinary1(int a ){
     int temp = 31;
     while(temp>=0){
          int value = a>>temp&1;
          printf("%d",value);

          if((temp)%4==0){
               printf(" ");
          }
          temp--;
     }
}

3、负数在内存中的存储
（1）一个字节的取值范围
（2）负数的表示形式
（3）原码、反码、补码

4、取值范围

十二、类型说明符
1、short和long

（1） short和long可以提供不同长度的整型数，也就是可以改变整型数的取值范围。在64bit编译器环境下，int占用4个字节（32bit），取值范围是-231~231-1；short占用2个字节（16bit），取值范围是-215~215-1；long占用8个字节（64bit），取值范围是-263~263-1
（2） 总结一下：在64位编译器环境下，short占2个字节(16位)，int占4个字节(32位)，long占8个字节(64位)。因此，如果使用的整数不是很大的话，可以使用short代替int，这样的话，更节省内存开销。
（3） 世界上的编译器林林总总，不同编译器环境下，int、short、long的取值范围和占用的长度又是不一样的。比如在16bit编译器环境下，long只占用4个字节。不过幸运的是，ANSI \ ISO制定了以下规则：
a、short跟int至少为16位(2字节)
b、long至少为32位(4字节)
c、short的长度不能大于int，int的长度不能大于long
d、char一定为为8位(1字节)，毕竟char是我们编程能用的最小数据类型
（4） 可以连续使用2个long，也就是long long。一般来说，long long的范围是不小于long的，比如在32bit编译器环境下，long long占用8个字节，long占用4个字节。不过在64bit编译器环境下，long long跟long是一样的，都占用8个字节。
（5） 还有一点要明确的是：short int等价于short，long int等价于long，long long int等价于long long
2、signed和unsigned
（1） 首先要明确的：signed int等价于signed，unsigned int等价于unsigned
（2）signed和unsigned的区别就是它们的最高位是否要当做符号位，并不会像short和long那样改变数据的长度，即所占的字节数。
（3）signed：表示有符号，也就是说最高位要当做符号位，所以包括正数、负数和0。其实int的最高位本来就是符号位，已经包括了正负数和0了，因此signed和int是一样的，signed等价于signed int，也等价于int。signed的取值范围是-231 ~ 231 - 1
（4）unsigned：表示无符号，也就是说最高位并不当做符号位，所 以不包括负数。在64bit编译器环境下面，int占用4个字节（32bit），因此unsigned的取值范围是：0000 0000 0000 0000 0000 0000 0000 0000 ~ 1111 1111 1111 1111 1111 1111 1111 1111，也就是0 ~ 232 - 1

十三、位运算
1、& 按位与
（1）功能
只有对应的两个二进位均为1时，结果位才为1，否则为0。
（2）举例: 比如9&5，其实就是1001&101=1，因此9&5=1
（3）规律
二进制中，与1相&就保持原位，与0相&就为0

2、| 按位或
（1）功能
只要对应的二个二进位有一个为1时，结果位就为1，否则为0。
（2）举例: 比如9|5，其实就是1001|101=1101，因此9|5=13

3、^ 按位异或
（1） 功能
当对应的二进位相异（不相同）时，结果为1，否则为0。
（2）举例: 比如9^5，其实就是1001^101=1100，因此9^5=12
4、 规律
（1）相同整数相^的结果是0。比如5^5=0
（2）多个整数相^的结果跟顺序无关。比如5^6^7=5^7^6
（3）因此得出结论：a^b^a = b

5、<< 左移
把整数a的各二进位全部左移n位，高位丢弃，低位补0。左移n位其实就是乘以2的n次方，由于左移是丢弃最高位，0补最低位，所以符号位也会被丢弃，左移出来的结果值可能会改变正负性

6、>> 右移
把整数a的各二进位全部右移n位，保持符号位不变。右移n位其实就是除以2的n次方。为正数时， 符号位为0，最高位补0；为负数时，符号位为1，最高位是补0或是补1 取决于编译系统的规定

十四、char类型
1、存储细节
ASCII单字节表（双字节GBK\GB2312\GB18030\Unicode）
2、常见错误
char c = A;
char c = "A";
char c = 'ABCD';
char c = '男';
3、当做整型使用
在-128~127范围内，可以当做整数来用
4、%c和%d\%i的使用
printf(“%d”, ‘A’);
printf(“%c”, 68);

5、转义字符

转义字符	意义	ASCII码值
\n	将当前位置移到下一行开头（回车换行）	10
\t	跳到下一个TAB位置	9
\\	代表一个反斜线字符	92
\'	代表一个单引号字符	39
\"	代表一个双引号字符	34
\0	空字符	0

//将一个小写字母转为大写
char upper(char c){
     if(c>='a'&&c<='z'){
          return c-('a'-'A');
     }else{
          return c;
     }
}