【黑马程序员】---C语言数据类型总结02

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

C语言数据类型总结-（2）

1.指针

用来存放变量地址的变量，就称为"指针变量"。可以用指针类型来声明。

指针的定义 类名标识符  *指针变量名;

int *p;
int a = 90;
// 指针变量p指向了变量a
p = &a;
*p = 10;

a = 20;
printf("%d\n", *p);

指针变量是用来存放变量地址的，不要给它随意赋值一个常数。

int *p; 
p = 200; // 这是错误的

// 实例代码  指针的用途
// 写一个函数swap，接收2个整型参数，功能是互换两个实参的值
#include <stdio.h>
void swap(int *v1, int *v2);
int main()
{
    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 = *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;
    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;
}

指向指针的指针

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

心得体会：

（1）"*"是一个说明符，用来说明这个变量是个指针变量

（2）指针变量前面的类型标识符表示指针变量所指向的变量的类型，而且只能指向这种类型的变量

（3）指针变量只能存储地址,它能够根据一个地址值，访问对应的存储空间

（4）指针变量未经过初始化，不要拿来间接访问其他存储空间

2.指针和数组

数组及其数组元素都占有存储空间，都有自己的地址，因此指针变量可以指向整个数组，也可以指向数组元素。

    int ages[5] = {10, 9, 8, 67, 56};
    int *p;
    // 指针变量p指向了数组的首元素
    p = &ages[0];
    // 数组名就是数组的地址，也是数组首元素的地址
    //p = ages;

心得体会：

（1）数组名 = 数组的地址 = 数组首元素的地址

（2）可以用指针间接的访问数组元素p[i]或者*[p + i];

（3）指针变量+1，地址值究竟加多少，取决于指针的类型，int +4；char +1；double +8；

3.指针和字符串

定义字符串有两种方式：指针和数组

// 字符串变量
char name[] = "it";
name[0] = 'T';
printf("%s\n", name);

 // 字符串常量
char *name2 = "it";		// 指针变量name2指向了字符串的首字符

定义字符串数组的两种方式：指针数组和二维数组

// 指针数组（字符串数组）
char *names[5] = {"jack", "rose", "jake"};
    
// 二维字符数组（字符串数组）
char names2[2][10] = {"jack", "rose"};

实例代码演示：

定义字符串有两种方式：指针和数组

// 编写一个int string_len(char *s)，返回字符串s的字符长度
int string_len(char *s);

int main()
{
    int size = string_len("zhamengjun");
    
    printf("%d\n", size);
    return 0;
}

int string_len(char *s)
{
    // 1.定义一个新的指针变量指向首字符
    char *p = s;

    while ( *s != '\0' )
    {
        s++;
    }
    return s - p - 1;
}

心得体会：

（1）利用数组定义的字符串，里面的字符串是可以修改的；而利用指针定义的字符串，里面的字符串是不可以修改的。

（2）利用数组定义的字符串，使用在经常需要修改的字符串内容；而利用指针定义的字符串，用在不能修改的字符串，并且该字符串使用频率很高

4.指针与函数

（1）返回指针的函数

返回指针的函数的一般形式为：类型名 * 函数名(参数列表)

#include <stdio.h>
char *test();
int main()
{
    char *name = test();
    
    printf("name=%s\n", name);
    
    return 0;
}
char *test()
{
    return "rose";
}

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

#include <stdio.h>
int sum(int a, int b) {
    return a + b;
}
int main()
{
    // 定义一个指针变量p，指向sum函数
    int (*p)(int a, int b) = sum;
    // 或者 int (*p)(int, int) = sum;
    // 或者 int (*p)() = sum;
    
    // 利用指针变量p调用函数
    int result = (*p)(1, 3);
    // 或者 int result = p(1, 3);
    
    printf("%d", result);
    return 0;
}

心得体会：

（1）(*p)是固定写法，代表指针变量p将来肯定是指向函数

（2）使用指针间接调用函数有两种方式，1.先利用*p取出指向的函数，再传入参数调用函数 2.直接用p
（3）形式参数的变量名可以省略，甚至整个形式参数列表都可以省略

（4）指针p指向函数，用 p = sum

指向函数的指针的应用：

#include <stdio.h>

// 减法运算
int minus(int a, int b) {
    return a - b;
}

// 加法运算
int sum(int a, int b) {
    return a + b;
}

// 这个counting函数是用来做a和b之间的计算，至于做加法还是减法运算，由函数的第1个参数决定
void counting( int (*p)(int, int) , int a, int b) {
    int result = p(a, b);
    printf("计算结果为：%d\n", result);
}

int main()
{
    // 进行加法运算
    counting(sum, 6, 4);
    
    // 进行减法运算
    counting(minus, 6, 4);
    
    return 0;
}

5.结构体

 数组：只能由多个相同类型的数据构成
 结构体：可以由多个不同类型的数据构成

定义结构体变量的3种方式
 1> 先定义类型，再定义变量（分开定义）

 struct Student
 {
    int age;
 };
 struct Student stu;

 2> 定义类型的同时定义变量

struct Student
 {
    int age;
 } stu;
 struct Student stu2;

 3> 定义类型的同时定义变量（省略了类型名称）

 struct
 {
    int age;
 } stu;

结构体的内存细节

    // 1.定义结构体类型(并不会分配存储空间)
    struct Date
    {
        int year;
        int month;
        int day;
    };

    // 2.定义结构体变量（真正分配存储空间）
	
    struct Date d1 = {2011, 4, 10}; 
    struct Date d2 = {2012, 8, 9};
    // 会将d1所有成员的值对应地赋值给d2的所有成员
    d2 = d1;

结构体类型的作用域
 1> 定义在函数外面：全局有效（从定义类型的那行开始，一直到文件结尾）
 2> 定义在函数（代码块）内部：局部有效（从定义类型的那行开始，一直到代码块结束）

结构体的使用

1.一般对结构体变量的操作是以成员为单位进行的，引用的一般形式为：结构体变量名.成员名
2.如果某个成员也是结构体变量，可以连续使用成员运算符"."访问最低一级成员
3.相同类型的结构体变量之间可以进行整体赋值

心得体会：

（1）结构体跟数组一样，只有在定义的时候才能进行初始化操作

（2）相同类型结构体变量之间的赋值，是将一个结构体变量所有成员的值对应地赋值给另一个结构体变量
（3）结构体不能重复定义

6.结构体数组

结构体数组的定义：

 struct RankRecord records[3] =
    {
        {1, "jack", 5000},
        
        {2, "jim", 500},
        
        {3, "jake",300}
    };

心得体会：

（1）结构体数组的定义跟结构体的定义差不多，都有3中方式。

（2）结构体数组成员的访问：records[0].no;

7.结构体与指针

结构体指针变量的定义形式： struct 结构体名称 *指针变量名

int main()
{
    struct Student
    {
        int no;
        int age;
    };
    // 结构体变量
    struct Student stu = {1, 20}; 
    // 指针变量p将来指向struct Student类型的数据
    struct Student *p; 
    // 指针变量p指向了stu变量
    p = &stu; 
    p->age = 30;
    // 第一种方式
    printf("age=%d, no=%d\n", stu.age, stu.no);  
    // 第二种方式
    printf("age=%d, no=%d\n", (*p).age, (*p).no); 
    // 第三种方式
    printf("age=%d, no=%d\n", p->age, p->no);
    return 0;
}

心得体会：

（1）利用指针访问结构体成员，p->成员名称 或者 是  (*p).成员名称

8.结构体与函数

#include <stdio.h>
struct Student
{
    int age;
    int no;
};
// 修改函数内部结构体的成员不会影响外面的实参结构体
void test(struct Student s)
{
    s.age = 30;
    s.no = 2;
}

// 会影响外面的实参结构体
void test2(struct Student *p)
{
    p->age = 15;
    p->no = 2;

}
int main()
{
    struct Student stu = {28, 1}; 
    test(stu);
	test2(&stu);
    printf("age=%d, no=%d\n", stu.age, stu.no); 
    return 0;
}

void test3(struct Student *p)
{
    struct Student stu2 = {15, 2};
    p = &stu2;
    p->age = 16;
    p->no = 3;
}

心得体会：

（1）如果结构体作为函数参数，只是将实参结构体所有成员的值对应地赋值给了形参结构体的所有成员

（2）如果结构体指针作为函数参数，则是将实参结构体地址赋值给结构体指针变量

9.枚举

枚举是C语言中的一种基本数据类型，并不是构造类型，它可以用于声明一组常数。当一个变量有几个固定的可能取值时，可以将这个变量定义为枚举类型。

一般形式为： enum　枚举名　{枚举元素1,枚举元素2,……};

#include <stdio.h>
int main()
{
    // 1.定义枚举类型
    enum Season
    {
        spring = 1,
        summer,
        autumn,
        winter
    };
    // 2.定义枚举变量
    enum Season s = 100000;
    printf("%d\n", s); 
    return 0;
}

遍历枚举元素

enum Season {spring, summer, autumn, winter} s;

// 遍历枚举元素
for (s = spring; s <= winter; s++) {
    printf("枚举元素：%d \n", s);
}

心得体会：

（1）C语言编译器会将枚举元素(spring、summer等)作为整型常量处理，称为枚举常量。

（2）枚举元素的值取决于定义时各枚举元素排列的先后顺序。默认情况下，第一个枚举元素的值为0，第二个为1，依次顺序加1

（3） 也可以在定义枚举类型时改变枚举元素的值