c语言提高学习笔记——02-c提高04day

在学习c语言提高总结了笔记，并分享出来。有问题请及时联系博主：Alliswell_WP，转载请注明出处。

02-c提高04day

目录：
一、多维数组
1、一维数组
（1）数组名
（2）下标引用
（3）数组和指针
（4）作为函数参数的数组名
2、多维数组
（1）数组名
（2）指向数组的指针（数组指针）
3、总结
（1）编程提示
（2）内容总结
二、结构体
1、结构体基础知识
（1）结构体类型的定义
（2）结构体变量的定义
（3）结构体变量的初始化
（4）结构体成员的使用
2、结构体赋值
（1）赋值基本概念
（2）结构体嵌套一级指针

 

一、多维数组

1、一维数组
·元素类型角度：数组是相同类型的变量的有序集合
·内存角度：连续的一大片内存空间

在讨论多维数组之前，我们还需要学习很多关于一维数组的知识。首先让我们学习一个概念。

（1）数组名
考虑下面这些声明：

int a;
int b[10];

我们把a称作变量，因为它是个单一的值，这个变量的类型是一个整数。我们把b称作数组，因为它是一些值的集合。下标和数名一起使用，用于标识该集合中某个特定的值。例如，b[0]表示数组b的第1个值，b[4]表示第5个值。每个值都是一个特定的标量。

那么问题是b的类型是什么？它所表示的又是什么？一个合乎逻辑的答案是它表示整个数组，但事实并非如此。在C中，在几乎所有数组名的表达式中，数组名的值是一个指针常量，也就是数组第一个元素的地址。它的类型取决于数组元素的类型：如果他们是int类型，那么数组名的类型就是“指向int的常量指针”；如果它们是其他类型，那么数组名的类型也就是“指向其他类型的常量指针"。

请问：指针和数组是等价的吗？
答案是否定的。数组名在表达式中使用的时候，编译器才会产生一个指针常量。那么数组在什么情况下不能作为指针常量呢？在以下两种场景下：

■当数组名作为sizeof操作符的操作数的时候，此时sizeof返回的是整个数组的长度，而不是指针数组指针的长度。
■当数组名作为&操作符的操作数的时候，此时返回的是一个指向数组的指针，而不是指向某个数组元素的指针常量。

int arr[10]；
//arr=NULL；//arr作为指针常量，不可修改
int *p=arr;//此时arr作为指针常量来使用
printf(""sizeof(arr):%d\n",sizeof(arr))；//此时sizeof结果为整个数组的长度
printf("&arr type is %s\n",typeid(&arr).name());//int(*)[10]而不是int*

 练习：

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<string.h>
#include<stdlib.h>

void test()
{
    int arr[] = {1, 2, 3, 4};
    
    //1.sizeof  2.对数组名取地址&arr
    //以上两种情况下，数组名不是指向首元素的指针
    //以上两种情况下，数组名是数组类型
    //除了以上两点之外，数组名在其他任何情况下都是指向首元素的指针
    
    printf("sizeof arr:%d\n", sizeof(arr));
    
    printf("&arr addr: %d\n", &arr);
    printf("&arr + 1 addr:%d\n", &arr + 1);
    
    //arr = NULL;//err，数组名是一个常量指针
    
}


int main(){

    test();
    
    system("pause");
    return EXIT_SUCCESS;
}

（2）下标引用
int arr[]={1,2,3,4,5,6};

*（arr+3)，这个表达式是什么意思呢？
首先，我们说数组在表达式中是一个指向整型的指针，所以此表达式表示arr 指针向后移动了3个元素的长度。然后通过间接访问操作符从这个新地址开始获取这个位置的值。这个和下标的引用的执行过程完全相同。所以如下表达式是等同的：

*(arr + 3)
arr[3]

问题1：数组下标可否为负值？

问题2：请阅读如下代码，说出结果：

int arr[]={5,3,6,8,2,9}；
int *p=arr +2;
printf("*p=%d\n",*p)；
printf("*p=%d\n",p[-1])；

那么是用下标还是指针来操作数组呢？对于大部分人而言，下标的可读性会强一些。

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<string.h>
#include<stdlib.h>

//代码可读性，可读性比效率更重要
void printArray(int* arr, int len)//int* arr最好写成int arr[]
{
    for(int i = 0; i < len; ++i)
    {
        printf("%d", arr[i]);//这种可读性好
        printf("%d", *(arr + i));
    }
}

void test()
{
    int arr[] = {1, 2, 3, 4};
    
    //1.sizeof  2.对数组名取地址&arr
    //以上两种情况下，数组名不是指向首元素的指针
    //以上两种情况下，数组名是数组类型
    //除了以上两点之外，数组名在其他任何情况下都是指向首元素的指针
    
    printf("sizeof arr:%d\n", sizeof(arr);
    
    printf("&arr addr: %d\n", &arr);
    printf("&arr + 1 addr:%d\n", &arr + 1);
    
    //arr = NULL;//err，数组名是一个常量指针
    
    //数组下标能否是负数？
    int* p = arr;
    p += 3;
    printf("p[-1]:%d", p[-1]);//p[-1]转换为*(p-1)，所以可以为负数
}


int main(){

    test();
    
    system("pause");
    return EXIT_SUCCESS;
}

（3）数组和指针
指针和数组并不是相等的。为了说明这个概念，请考虑下面两个声明：

int a[10];
int *b；

声明一个数组时，编译器根据声明所指定的元素数量为数组分配内存空间，然后再创建数组名，指向这段空间的起始位置。声明一个指针变量的时候，编译器只为指针本身分配内存空间，并不为任何整型值分配内存空间，指针并未初始化指向任何现有的内存空间。

因此，表达式*a是完全合法的，但是表达式*b却是非法的。*b将访问内存中一个不确定的位置，将会导致程序终止。另一方面b++可以通过编译，a++却不行，因为a是一个常量值。

 

（4）作为函数参数的数组名
当一个数组名作为一个参数传递给一个函数的时候发生什么情况呢？我们现在知道数组名其实就是一个指向数组第1个元素的指针，所以很明白此时传递给函数的是一份指针的拷贝。所以函数的形参实际上是一个指针。但是为了使程序员新手容易上手一些，编译器也接受数组形式的函数形参。因此下面两种函数原型是相等的：

int print array(int *arr)；
int print array(int arr[]);

我们可以使用任何一种声明，但哪一个更准确一些呢？答案是指针。因为实参实际上是个指针，而不是数组。同样 sizeof arr值是指针的长度，而不是数组的长度。

现在我们清楚了，为什么一维数组中无须写明它的元素数目了因为形参只是一个指针，并不需要为数组参数分配内存。另一方面，这种方式使得函数无法知道数组的长度。如果函数需要知道数组的长度，它必须显式传递一个长度参数给函数。

2、多维数组

如果某个数组的维数不止1个，它就被称为多维数组。

（1）数组名
一维数组名的值是一个指针常量，它的类型是“指向元素类型的指针”，它指向数组的第1个元素。多维数组也是同理，多维数组的数组名也是指向第一个元素，只不过第一个元素是一个数组。例如：

int arr[3][10]

可以理解为这是一个一维数组，包含了3个元素，只是每个元素恰好是包含了10个元素的数组。arr就表示指向它的第1个元素的指针，所以arr是一个指向了包含了10个整型元素的数组的指针。

（2）指向数组的指针（数组指针）
数组指针，它是指针，指向数组的指针。
数组的类型由元素类型和数组大小共同决定：int array[5]的类型为int[5]；C语言可通过typedef定义一个数组类型：

定义数组指针有一下三种方式：

//方式一
void test01(){
    //先定义数组类型,再用数组类型定义数组指针
    int arr[10]={1,2,3,4,5,6,7,8,9,10};

    //有typedef是定义类型,没有则是定义变量,下面代码定义了一个数组类型ArrayType
    typedef int(ArrayType)[10];
    //int ArrayType[10];/定义一个数组,数组名为ArrayType

    ArrayType myarr;//等价于int myarr[10];
    ArrayType* pArr=&arr;//定义了一个数组指针pArr,并且指针指向数组arr
    for(int i=0;i<10;i++){
        printf("%d",(*pArr)[i]);
    }
    printf("\n");
}
//方式二
void test02(){
    int arr[10];
    //定义数组指针类型
    typedef int(*ArrayType)[10];
    ArrayType pArr=&arr;//定义了一个数组指针pArr,并且指针指向数组arr
    for(int i=0;i<10;i++){
    (*pArr)[i]=i+1;
    }
    for(int i=0;i<10;i++){
    printf("%d",(*pArr)[i]);
}
    printf("\n");
}
//方式三
void test03(){
    int arr[10];
    int(*pArr)[10]=&arr;
    for(int i=0;i<10;i++){
    (*pArr)[i]=i+1;
    }
    for(int i=0;i<10;i++){
        printf("%d",(*pArr)[i]);
    }
    printf("\n");
}

练习1：数组指针

 1 #define _CRT_SECURE_NO_WARNINGS
 2 #include<stdio.h>
 3 #include<string.h>
 4 #include<stdlib.h>
 5 
 6 //如何定义一个可以指向数组的指针？
 7 void test()
 8 {
 9     int arr[5] = {1, 2, 3, 4, 5};
10     
11     //1.我们先定义数组类型，再定义数组指针类型
12     typedef int (ARRAY_TYPE)[5];
13     
14     ARRAY_TYPE myarray;//相当于int myarray[5]
15     for(int i = 0; i < 5; ++i)
16     {
17         myarray[i] = 100 + i;
18     }
19     for(int i = 0; i < 5; ++i)
20     {
21         printf("%d ", myarray[i]);
22     }
23     
24     //对数组名取地址代表指向整个数组的指针
25     ARRAY_TYPE* pArray = &myarray;
26     pArray = &arr;
27     
28     //1）*pArray表示拿到pArray指针指向的整个数组
29     //2）*pArray类型就是数组名，指向首元素类型的指针
30     //*pArray先解引用，拿到数组名，即拿到指向首元素的指针，+1，拿到指向第二个元素的指针，再解引用，拿到第二个元素
31     printf("*(*pArray + 1):%d\n", *(*pArray + 1));//输出2
32     
33     //2.直接定义数组指针类型
34     typedef int(*ARRAY_POINTER)[5];
35     ARRAY_POINTER pArr = &arr;
36     
37     //3.直接定义数组指针变量
38     int(*pArrParam)[5] = &arr;
39     
40 }
41 
42 
43 int main(){
44 
45     test();
46     
47     system("pause");
48     return EXIT_SUCCESS;
49 }

练习2：通过指针操作二维数组

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<string.h>
#include<stdlib.h>

void test()
{
    int arr[3][3] = 
    {
        {1,2,3}, //二维数组名是什么类型？int(*)[3]
        {4,5,6},
        {7,8,9}
    };//可读性更强，相当于int arr[3][3] = ｛1,2,3,4,5,6,7,8,9｝;
    
    //对于二维数组同一维数组一样，除了sizeof对数组名取地址之外，那么数组名就是指向数组首元素的指针
    printf("*(*(arr + 2) + 1):%d", *(*(arr + 2) + 1));//8
}


int main(){

    test();
    
    system("pause");
    return EXIT_SUCCESS;
}

 练习3：二维数组当做函数形参

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<string.h>
#include<stdlib.h>

void printBiArray(int(*parr)[3], int len1, int len2)
{
    for(int i = 0; i < len1; ++i)
    {
        for(j = 0; j < len2; ++j)
        {
            //printf("%d ", *(*(parr + i) + j));
            printf("%d ", parr[i][j]);//可读性强
        }
    }
}

void test()
{
    int arr[3][3] = 
    {
        {1,2,3},
        {4,5,6},
        {7,8,9}
    };//可读性更强，相当于int arr[3][3] = ｛1,2,3,4,5,6,7,8,9｝;
    printBiArray(arr, 3, 3);
    
}


int main(){

    test();
    
    system("pause");
    return EXIT_SUCCESS;
}

---

》扩展：常用的几种传参

void printBiArray1(int(*parr)[3], int len1, int len2)
{
    for(int i = 0; i < len1; ++i)
    {
        for(j = 0; j < len2; ++j)
        {
            //printf("%d ", *(*(parr + i) + j));
            printf("%d ", parr[i][j]);//可读性强
        }
    }
}

void printBiArray2(int parr[3][3], int len1, int len2)
{
    for(int i = 0; i < len1; ++i)
    {
        for(j = 0; j < len2; ++j)
        {
            //printf("%d ", *(*(parr + i) + j));
            printf("%d ", parr[i][j]);//可读性强
        }
    }
}

void printBiArray3(int parr[][3], int len1, int len2)
{
    for(int i = 0; i < len1; ++i)
    {
        for(j = 0; j < len2; ++j)
        {
            //printf("%d ", *(*(parr + i) + j));
            printf("%d ", parr[i][j]);//可读性强
        }
    }
}

typedef int(*ARR_TYPE)[3];
void printBiArray4(ARR_TYPE parr, int len1, int len2)
{
    for(int i = 0; i < len1; ++i)
    {
        for(j = 0; j < len2; ++j)
        {
            //printf("%d ", *(*(parr + i) + j));
            printf("%d ", parr[i][j]);//可读性强
        }
    }
}

typedef int(ARR_TYPE)[3];
void printBiArray5(ARR_TYPE *parr, int len1, int len2)
{
    for(int i = 0; i < len1; ++i)
    {
        for(j = 0; j < len2; ++j)
        {
            //printf("%d ", *(*(parr + i) + j));
            printf("%d ", parr[i][j]);//可读性强
        }
    }
}

 

---

练习4：指针数组排序——选择排序

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<string.h>
#include<stdlib.h>

void SelectSort(char** arr, int len)
{
    for(int i = 0; i < len; ++i)
    {
        int min = i;
        for(int j = i + 1; j < len; ++j)
        {
            if(strcmp(arr[j], arr[min]) < 0)
            {
                min = j;
            }
        }
        //交换
        if(min != i)
        {
            char* temp = arr[min];
            arr[min] = arr[i];
            arr[i] = temp;
        }
    }
}

void PrintArray(char** arr, int len)
{
    for(int i = 0; i < len; ++i)
    {
        printf("%s\n", arr[i]);
    }
}

void test()
{
    char* pArr[] = {"ddd", "ccc", "fff", "hhh", "ppp", "rrr"};
    //pArr是什么类型的？char**类型的
    int len = sizeof(pArr) / sizeof(char*);//等价于sizeof(pArr) / sizeof(pArr[0])
    PrintArray(pArr, len);
    //选择排序
    SelectSort(pArr, len);
    printf("-----------------------\n");
    PrintArray(pArr, len);
}

int main(){

    test();
    
    system("pause");
    return EXIT_SUCCESS;
}

3、总结

（1）编程提示
■源代码的可读性几乎总是比程序的运行时效率更为重要
■只要有可能，函数的指针形参都应该声明为const
■在多维数组的初始值列表中使用完整的多层花括号提供可读性

（2）内容总结
在绝大多数表达式中，数组名的值是指向数组第1个元素的指针。这个规则只有两个例外，sizeof和对数组名&。

指针和数组并不相等。当我们声明一个数组的时候，同时也分配了内存。但是声明指针的时候，只分配容纳指针本身的空间。

当数组名作为函数参数时，实际传递给函数的是一个指向数组第1个元素的指针。
我们不单可以创建指向普通变量的指针，也可创建指向数组的指针。

二、结构体

1、结构体基础知识
（1）结构体类型的定义

struct Person{
    char name[64];
    int age;
};
　typedef struct Person MyPerson;
  //等价于下边
typedef struct Person{
    char name[64];
    int age;
}MyPerson;

注意：定义结构体类型时不要直接给成员赋值，结构体只是一个类型，编译器还没有为其分配空间，只有根据其类型定义变量时，才分配空间，有空间后才能赋值。

（2）结构体变量的定义

struct Person{
    char name[64];
    int age;
}p1;//定义类型同时定义变量

struct{
    char name[64];
    int age;
}p2;//定义类型同时定义变量

struct Person p3;//通过类型直接定义

（3）结构体变量的初始化

struct Person{
    char name[64];
    int age;
}pl={"john",10};//定义类型同时初始化变量

struct{
    char name[64];
    int age;
}p2={"Obama",30};//定义类型同时初始化变量

struct Person p3={"Edward",33};//通过类型直接定义

（4）结构体成员的使用

单个结构体变量

struct Person{
    char name[64];
    int age;
};
void test(){
    //在栈上分配空间
    struct Person pl;
    strcpy(pl.name,"John");
    pl.age=30;
    //如果是普通变量，通过点运算符操作结构体成员
    printf("Name:%s Age:%d\n",pl.name,pl.age);

    //在堆上分配空间
    struct Person*p2=(struct Person*)malloc(sizeof(struct Person));
    strcpy(p2->name,"Obama");
    p2->age=33;
    //如果是指针变量，通过->操作结构体成员
    printf（"Name:%s Age:%d\n"，p2->name,p2->age);
}

多个结构体变量

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<string.h>
#include<stdlib.h>

struct Person{
    char name[64];
    int age;
};

//打印
void printPersons(struct* persons, int len)
{
    for(int i = 0; i < len; ++i)
    {
        printf("Name:%s Age:%d\n", persons[i].name, persons[i].Age);
    }
}

//多个结构体变量
void test()
{
    //在栈上分配结构体数组空间
    struct Person persons[] = {
        {"aaa", 20},
        {"bbb", 30},
        {"ccc", 40},
        {"ddd", 50},
        {"eee", 60},
        {"fff", 70},
    };
    int len = sizeof(persons) / sizeof(struct Person);//或者用sizeof(persons[0])
    printPersons(persons, len);
    
    //在堆上分配结构体数组空间
    struct Person* ps = malloc(sizeof(struct Person) * 6);
    for(int i = 0; i < 6; ++i)
    {
        sprintf(ps[i].name, "Name_%d"， i + 1);
        ps[i].age = 100 + i;
    }
    printPersons(ps, 6);
}

int main(){

    test();
    
    system("pause");
    return EXIT_SUCCESS;
}

 

2、结构体赋值
（1）赋值基本概念
相同的两个结构体变量可以相互赋值，把一个结构体变量的值拷贝给另一个结构体（逐字节拷贝），这两个变量还是两个独立的变量。

struct Person{
    char name[64];
    int age;
};
void test(){
    //在栈上分配空间
    struct Person pl={"John",30};
    struct Person p2={"Obama",33};
    printf("Name:%s Age:%d\n",pl.name,pl.age);
    printf("Name:%s Age:%d\n",p2.name,p2.age);
    //将p2的值赋值给p1
    p1=p2;
    printf("Name:%s Age:%d\n",pl.name,pl.age);
    printf("Name:%s Age:%d\n",p2.name,p2.age);
}

练习：堆上结构体的拷贝

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<string.h>
#include<stdlib.h>

struct Teacher{
    char* name;
    int age;
};


void test()
{
    struct Teacher teacher1;
    teacher1.name = malloc(sizeof(char) * 64);//在堆上开辟内存
    memset(teacher1.name, 0, 64);
    strcpy(teacher1.name, "aaa");
    teacher1.age = 20;
    
    struct Teacher teacher2;
    teacher2.name = malloc(sizeof(char) * 128);
    memset(teacher2.name, 0, 128);
    strcpy(teacher2.name, "bbbbbbbbbbbbb");
    teacher2.age = 30;
    
    printf("Name:%s Age:%d\n",teacher1.name,teacher1.age);
    printf("Name:%s Age:%d\n",teacher2.name,teacher2.age);
    
    //赋值报错？分析？？？
    //不使用默认的结构体
    //teacher1 = teacher2;//err
    //如果结构体内部有指针指向堆内存，那么就不能使用编译器默认的赋值行为，应该手动控制赋值过程
    //手动拷贝
    if(teacher1.name != NULL)
    {
        free(teacher1.name);
        teacher1.name = NULL;
    }    
    teacher1.name = malloc(strlen(teacher2.name) + 1);
    strcpy(teacher1.name, teacher2.name);
    teacher1.age = teacher2.age;
    
    printf("------------------\n");
    printf("Name:%s Age:%d\n",teacher1.name,teacher1.age);
    printf("Name:%s Age:%d\n",teacher2.name,teacher2.age);    
    
    
    //释放堆内存
    if(teacher1.name != NULL)
    {
        free(teacher1.name);
        teacher1.name = NULL;
    }
    if(teacher2.name != NULL)
    {
        free(teacher2.name);
        teacher2.name = NULL;
    }
}

int main(){

    test();
    
    system("pause");
    return EXIT_SUCCESS;
}

 赋值报错？分析？

解决：

（2）结构体嵌套一级指针

练习：

代码实现：

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<string.h>
#include<stdlib.h>

struct Person
{
    char* name;
    int age;
};

//分配内存
struct Person** allocateSpace()
{
    struct Person** temp = malloc(sizeof(struct Person*) * 3);
    for(int i = 0; i < 3; ++i)
    {
        temp[i] = malloc(sizeof(struct Person));
        temp[i]->name = malloc(sizeof(char) * 64);
        
        sprintf(temp[i]->name, "Name_%d", i + 1);
        temp[i]->age = 100 + i;
    }
    return temp;
}

//打印
void printPerson(struct Person** person)
{
    if(NULL == person)
    {
        return;
    }
    for(int i = 0; i < 3; ++i)
    {
        printf("Name:%s Age:%d\n", person[i]->name, person[i]->age);
    }
}

//释放内存
void freeSpace(struct Person** person)
{
    if(NULL == person)
    {
        return;
    }
    for(int i = 0; i < 3; ++i)
    {
        if(person[i] == NULL)
        {
            continue;
        }
        if(person[i]->name != NULL)
        {
            printf("Name:%s的内存被释放!\n",person[i]->name)
            free(person[i]->name);
            person[i]->name = NULL;
        }
        free(person[i]);
        person[i] = NULL;
    }
    free(person);
    person = NULL;
}


void test()
{
    struct Person** person = NULL;
    person = allocateSpace();
    printPerson(person);
    freeSpace(person);
}

int main(){

    test();
    
    system("pause");
    return EXIT_SUCCESS;
}

 

参考：

1）讲义：豆丁网：https://www.docin.com/p-2159552288.html
道客巴巴：https://www.doc88.com/p-6951788232280.html

 

在学习c语言提高总结了笔记，并分享出来。有问题请及时联系博主：Alliswell_WP，转载请注明出处。