黑马程序员（一）-------进制、内存、数组、指针、字符串

------- IOS培训、android培训、期待与您交流！ ----------

一、 函数

1. 定义函数的目的

将一个常用的功能封装起来，方便以后调用

2. 格式

 固定格式

返回值类型  函数名(形式参数列表) 

{

  函数体

}

3.函数的参数

1. 形参个数和实参一致：sum(10, 11, 12)

2. 参数的传递是值传递

3. 参数名不能跟函数内的局部变量同名

4.函数可以没有参数

4.函数注意

1.不能嵌套定义函数

2.死循环调用，自己调用自己

3.不能重复定义、可以重复声明

5.函数的声明

函数的声明作用：声明和定义，类似于身份证和人的关系，编译买机票、链接登机

只有函数声明、没有定义，编译警告、链接报错

二、 #include

1. #include的作用

纯粹是文件拷贝

三、 进制

多种进制：十进制、二进制、八进制、十六进制。也就是说，同一个整数，我们至少有4种表示方式

1. 二进制

1> 特点：只有0和1，逢2进1

2> 书写格式：0b或者0b开头

3> 使用场合：二进制指令\二进制文件，变量在内存中就是二进制存储

4> 二进制和十进制的互相转换

5>n为二进制位所能表示的数据范围（不考虑负数）：0~2的n次方-1

2. 八进制

1> 特点：0~7，逢八进一

2> 书写格式：0开头

3> 八进制和二进制的互相转换

 

3. 十六进制

1> 特点：0~F，逢十六进一

2> 书写格式：0x或者0X开头

3> 十六进制和二进制的互相转换

四、格式符

%d：以带符号的十进制形式输出整数，但不输出正号

%o以不带符号的八进制形式输出整数

%x：以不带符号的十六进制形式输出整数

%u：以不带符号的十进制形式输出整数

%c：输出一个字符

%s：输出一个或多个字符

%f：以小数形式输出单、双精度浮点数，默认输出6位小数

%e：以标准指数形式输出单、双精度数，数字部分小数位为6位

C语言中没有专门的2进制输出格式符，但是利用移位可以做到十进制对2进制的转换，如下：

int  main()

{

printBinary();

return 0;

}

void printBinary(int num)

{

int   temp = 32;

while(temp > 0)

{

int  value = num>>temp&1;

printf("%d",value);

temp--;

if  (temp%4 == 0)

{printf("    ");}

}

printf("\n");

}

五、 类型说明符

1. short和long

1>在64位编译器环境下，short占2个字节(16位)，int占4个字节(32位)，long占8个字节(64位)。因此，如果使用的整数不是很大的话，可以使用short代替int，这样的话，更节省内存开销。

2>ANSI \ ISO制定了以下规则：

 short跟int至少为16位(2字节)

long至少为32位(4字节)

short的长度不能大于int，int的长度不能大于long

char一定为为8位(1字节)

 3>可以连续使用2个long，也就是long long。一般来说，long long的范围是不小于long的，比如在32bit编译器环境下，long long占用8个字节，long占用4个字节。不过在64bit编译器环境下，long long跟long是一样的，都占用8个字节。

4>short int等价于short，long int等价于long，long long int等价于long long

 

1. 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的取值范围是-2^31 ~ 2^31 - 1

unsigned：表示无符号，也就是说最高位并不当做符号位，所 以不包括负数。在64bit编译器环境下面，int占用4个字节（32bit），因此unsigned的取值范围是：0000 0000 0000 0000 0000 0000 0000 0000 ~ 1111 1111 1111 1111 1111 1111 1111 1111，也就是0 ~ 2^32 - 1

六、 位运算

1. & 按位与

1> 功能

只有对应的两个二进位均为1时，结果位才为1，否则为0。

二进制中，与1相&就保持原位，与0相&就为0

2. | 按位或

1> 功能

只要对应的二个二进位有一个为1时，结果位就为1，否则为0。

3. ^ 按位异或

1> 功能

当对应的二进位相异（不相同）时，结果为1，否则为0。

2>规律

相同整数相^的结果是0。比如5^5=0

多个整数相^的结果跟顺序无关。比如5^6^7=5^7^6

因此得出结论：a^b^a = b

4. ~ 取反

对整数a的各二进位进行取反，符号位也取反（0变1，1变0）

5. << 左移

把整数a的各二进位全部左移n位，高位丢弃，低位补0。左移n位其实就是乘以2的n次方

6. >> 右移

把整数a的各二进位全部右移n位，保持符号位不变。右移n位其实就是除以2的n次方

为正数时， 符号位为0，最高位补0

为负数时，符号位为1，最高位是补0或是补1 取决于编译系统的规定

七、数组

1.基本概念

数组就是一组数据，一个数组只能存放相同类型的数据，里面存放的数据叫做“元素”

2. 定义

声明数组的类型

声明数组的元素个数（需要多少存储空间）

3. 格式

元素类型 数组名[元素个数];

比如：int ages[3];

4. 简单使用

简单初始化：int ages[5] = {19, 19, 20, 21, 25};

元素有顺序之分，每个元素都有一个唯一的下标（索引），从0开始

数组元素的访问：a[i]

5.初始化

int a[3] = {10, 9, 6};

 int a[3] = {10,9};

int a[] = {11, 7, 6};

int a[4] = {[1]=11,[0] = 7};

6.常见错误

int a[];

int[4] a;

int a[b];

a = {10, 11};

a[4] = {10,9,8,5};

7. 内存分析

数组存储空间的大小

存储空间的划分（内存的分配是从高地址到低地址进行的，但一个数组内部元素又是从低到高进行的）

数组名的作用，查看元素地址

数组越界的注意

8. 其他使用

数组与函数参数

数组元素作为函数参数

数组作为函数参数（sizeof注意）

遍历数组元素

两种方式遍历（while循环和for循环）

遍历元素值和元素地址

字符数组的使用

习题

设计一个函数，找出整型数组元素的最大值



#include <stdio.h>


int maxOfArray(int array[], int length)
{
    // 数组当做函数参数传递时，会当做指针变量来使用，指针变量在64bit编译器环境下，占据8个字节
    
    //int size = sizeof(array);
    //printf("array=%d\n", size);
    
    //sizeof(array);
    
    // 1.定义一个变量存储最大值(默认就是首元素)
    int max = array[0];
    
    // 2.遍历所有元素，找出最大值
    for (int i = 1; i<length; i++)
    {
        // 如果当前元素大于max，就用当前元素覆盖max
        if (array[i] > max)
        {
            max = array[i];
        }
    }
    
    return max;
}


int main()
{
    int ages[] = {11, 90, 67, 150, 78, 60, 70, 89, 100};
    
    int ages2[] = {11, 90, 67, 150, 78, 60, 70, 89, 100};
    
    //int size = sizeof(ages);
    
    //printf("ages=%d\n", size);
    int max = maxOfArray(ages, sizeof(ages)/sizeof(int));
    
    printf("%d\n", max);
    return 0;
}

八、 二维数组

二维数组是一个特殊的一维数组：它的元素是一维数组

1. 初始化

int a[3][4] = {1,2,3,4,5,6};

int a[3][4] = {{},{},{}};

数组元素简单访问

int a[][5] = {3,21,31,2,32,1};

九、字符串

1. 什么是字符串

简单的字符串”itcast”

一个’i’是一个字符

很多个字符组合在一起就是字符串了

2. 字符串的初始化

char a[] = “123”;  和 char a [] = {‘1’,’2’,’3’};的区别，可以比较大小

 “123”其实是由’1’、’2’、’3’、’\0’组成

“123”的存储分布

字符串的输出”%s”，’\0’是不会输出的

3. \0的作用

输出char a[] = {‘o’,’k’};

在char a[]前面搞个”mj”

输出”mj”

再输出a

char a[] = {‘i’,’t’,’\0’,’c’};

4. 常用字符串处理函数

strlen（注意中文）

习题

int main()
{
    /*
    int ages[5] = {10, 11, 90, 89, 70};
    
    int ages2[3][5]= {
        {10, 11, 90, 89, 70},
        
        {10, 11, 90, 89, 70},
        
        {10, 11, 90, 89, 70}
    };*/
    char cs[2][3];
    
    /*
     1 浅蓝色
     2 深蓝色
     3 黄色
     4 红色
     -1 没有
     */
    
    int cubes[5][5] = {
        {1, -1, -1, -1, -1},
        {1, 1, -1, 2, -1},
        {4, 1, 2, 2, 2},
        {4, 3, 3, 3, 3},
        {4, 3, 3, 3, 3}
    };
    
    /*
     1 白色
     2 黑色
     -1 没有
     */
    int wuzi[6][6] = {
        {};
    };
    
    
    return 0;
}

十、 字符串数组

1.使用场合

* 一维字符数组中存放一个字符串，比如一个名字char name[20] = "mj"

* 如果要存储多个字符串，比如一个班所有学生的名字，则需要二维字符数组，char names[15][20]可以存放15个学生的姓名(假设姓名不超过20字符)

* 如果要存储两个班的学生姓名，那么可以用三维字符数组char names[2][15][20]

2.初始化

char names[2][10] = { {'J','a','y','\0'}, {'J','i','m','\0'} };  

char names2[2][10] = { {"Jay"}, {"Jim"} };  

char names3[2][10] = { "Jay", "Jim" };

习题

#include <stdio.h>
int main()
{
    char name[] = "jack";
    
    char name1[] = "rose";
    
    char name2[] = "jim";
    
    char name3[] = "jake";
    
    char names[2][10]= {"jack", "rose"};
    
    //printf("%s\n", names[0]);
    
    //printf("%c\n", names[0][3]);
    
    char names2[2][10] =
    {
        {'j', 'a', 'c', 'k', '\0'},
        {'r', 'o', 's', 't', '\0'}
    };
    
    
    return 0;
}

十一、 指针

1. 定义的格式

类名标识符  *指针变量名;

int *p;

2. 先定义后赋值

1>简单取值

int a = 10;

int *p;

p = &a;

printf(“%d”, *p);

2>简单改值

*p = 9;

3. 定义的同时赋值

int a = 10;

int *p = &a;

4.易错点

int *p;   p = 1000;

int *p;   *p = 100;

 int *p;  *p = &a;

5. 清空指针

p = 0;

p = NULL;

十二、 指针与数组

指向一维数组元素的指针

指向的是数组第一个元素

十三、 指针与字符串

1. 其他定义字符串的方式

char *s = “mj”;

或者

char *s;

s = “mj”;

十四、 指向函数的指针

1. 为什么指针可以指向一个函数？

函数作为一段程序，在内存中也要占据部分存储空间，它也有一个起始地址，即函数的入口地址。函数有自己的地址，那就好办了，我们的指针变量就是用来存储地址的。因此，可以利用一个指针指向一个函数。其中，函数名就代表着函数的地址。

1. 指向函数的指针的定义

定义的一般形式：函数的返回值类型 (*指针变量名)(形参1, 形参2, ...);

2. 使用注意

由于这类指针变量存储的是一个函数的入口地址，所以对它们作加减运算(比如p++)是无意义的

指向函数的指针变量主要有两个用途：

调用函数

将函数作为参数在函数间传递

习题

编写一个函数void strlink(char *s, char *t)  将字符串t连接到字符串s的尾部

#include <stdio.h>


void strlink(char *s, char *t);


int main()
{
    char s1[20] = "michael ";
    char s2[] = "jackson";
    
    strlink2(s1, s2);
    
    printf("%s\n", s1);
    
    return 0;
}


void strlink(char *s, char *t)
{
    // 判断s[i]是否为字符串的尾部
    while ( *s != '\0' )
    {
        s++;
    }
    
    // 拷贝t的内容到s的后面
    while ( (*s = *t) != '\0' )
    {
        s++;
        t++;
    }
}

今天学了进制、内存、字符串和数组，指针很难理解，但是老师讲的很细心很透彻，让我对指针有了一个全新的认识，如果你也感兴趣，就来黑马IOS论坛http://bbs.itheima.com/forum-184-1.html大家一起讨论吧