精华内容
下载资源
问答
  • c语言结构体

    2019-07-30 19:58:56
    c语言结构体关键字 **struct 结构体名 { 成员1类型 成员1变量名; 成员2类型 成员2变量名; 成员3类型 成员3变量名; … };** 结构名,成员变量名:要符合**c语言标识符**的规定。 成员类型:只要是c语言合法...

    1,结构体:自定义的一种数据类型
    1.1定义
    struct ->c语言的结构体的关键字
    **struct 结构体名
    {
    成员1类型 成员1变量名;
    成员2类型 成员2变量名;
    成员3类型 成员3变量名;

    	};**
    	
    	结构名,成员变量名:要符合**c语言标识符**的规定。
    	成员类型:只要是c语言合法的数据类型都可以
    	
    	struct 结构体名 这个整体就是我们新定义的{结构体}类型 
    		
    	定义好了之后这个新的类型就和我们之前学过的类型是一样的,int ,char ......。
    	我们就可以使用这个类型了
    	
    	struct test
    	{
    		int a;
    		char b;
    	};
    	写完以上定义语句之后:我们就有了一个新的数据类型  -》struct test
    	这个新的数据类型中有两个成员:a,b
    	那么我想定义一个这样的类型的变量,该怎么定义呢?
    	
    	类型名 变量名;
    	**struct test t**;//定义了一个变量t,它的类型是struct test
    	
    例子:
    	struct student
    	{
    		int num;//学号
    		char name[20];//姓名
    		float score;//成绩
    	};
    	
    	上面定义了一个新的类型,类型名叫做struct student,这个类型可以用来描述“学生”
    	并且这个类型,包含了三个成员变量:
    		num
    		name
    		score
    		
    	如果要定义一个这样的变量,来保存学生。该怎么定义?
    	struct student t;
    	定义了一个变量t,它的类型是struct student,有三个成员变量,分别表示他的学号姓名成绩
    		
    那么这三个成员在内存中是怎么分布的。
    

    1.2结构体成员的内存布局
    struct student t;
    (1)sizeof(t) == sizeof(struct student) == ?
    要符号一下规则
    (a)结构体类型所占内存是其所有成员变量之和!
    (b)"字节对齐"的问题
    “字节对齐”是从cpu的效率来考虑的,在不同的cpu和编译器下,字节对齐的方式是不一样的

    1,有些编译器来讲:要求每个变量的地址必须是4的倍数:4字节对齐
    struct test
    {
    char a;
    char b;
    };
    sizeof(struct tets) == 8;

    			struct test
    			{
    				char a;
    				int b;
    			};
    			sizeof(struct tets) == 8;
    

    2,有些编译器:要求每个变量按他的类型的长度进行对齐,并且结构体的首地址必须是4的倍数
    struct test
    {
    char a;
    char b;
    };
    sizeof(struct tets) == 2;

    			struct test
    			{
    				char a;
    				int b;
    			};
    			sizeof(struct tets) == 8;
    				a---b
    				
    			struct test
    			{
    				char c;
    				char a;
    				int b;
    			};	
    			sizeof(struct tets) == 8;
    				ca--b
    		
    			struct test
    			{
    				char a;
    				int b;
    				char c;
    			};	
    		
    			sizeof(struct tets) == 12;
    			a---b   c---
    		
    		在x86的gcc编译器是第二种方式
    

    1.3 结构体成员变量的引用
    怎么访问结构体中的各成员变量 :
    (1)结构体变量名.成员变量名
    . :域操作符 。取组合类型中的成员变量

    		struct student
    		{
    			int num;//学号
    			char name[20];//姓名
    			float score;//成绩
    		};
    		
    		struct student t;
    		t.num
    		t.name
    		t.score
    

    成员变量与普通的用法和含义一致(左右值)
    t.num = 1;//t.num表示变量num的左值
    printf("%d\n",t.num);//右值

    		t.name = "zhangsan";//error
    				char a[10] = "lisi";//正确的
    				char a[10];
    				a = "lisi";//没有这种写法
    				a[0] = 'l';
    				a[1] = 'i';
    				......
    		同样的:
    		t.name[0] = 'z';
    		t.name[1] = 'h';
    

    strcpy(t.name,“zhangsan”);//字符数组的赋值,应该要用这个函数

    	(2)(*结构体指针变量名).成员变量名
    		struct student
    		{
    			int num;//学号
    			char name[20];//姓名
    			float score;//成绩
    		};
    		
    		struct student * p;//定义了一个指针变量p,指向的类型是 struct student
    		
    		struct student t;
    		p = &t;//p保存了t的地址
    		(*p).num = 2;
    		..........
    		
    		struct student * p;
    		p = (struct student *)malloc(sizeof(struct student));
    		(*p).num = 3;
    		(*p).score = 90;
    		strcpy((*p).name,"lisi");
    		
    		
    	(3)结构体指针变量名->成员变量名		(对第二种情况的改进)
    		struct student * p;
    		p = (struct student *)malloc(sizeof(struct student));
    		
    		p->num = 4;
    		p->score = 80;
    		strcpy(p->name,"wangwu");
    		
    		
    1.4结构体变量的初始化
    	结构体的初始化用{}
    	
    	struct data
    	{
    		int y,m,d;
    		/*
    		int y;
    		int m;
    		int d;
    		*/
    	};
    	
    	struct student
    	{
    		int num;//学号
    		char name[20];//姓名
    		float score;//成绩
    		struct data birth;//出生年月日//成员变量可以是结构体
    	};
    		
    	(1)按定义时的顺序依次初始化各成员变量,用逗号隔开
    			struct student t = {
    					1,//学号
    					"zhangsan",//姓名
    					100,
    					{
    						1999,
    						12,
    						20
    					}
    			};
    			
    	(2)不按顺序,想初始化哪个就初始化哪个成员变量
    			{}中:.成员变量名 = 值
    			struct student t = {
    				.name = "lisi",
    				
    				.birth = {
    					1990,
    					12,
    					9
    				}
    			};
    	(3)结构体数组初始化
    		struct student t[3];//定义了一个数组,名字叫做t,有三个成员变量,每个都是结构体类型数据
    		它的初始化,其实就是要同时符合数组和结构体的规定
    		
    		struct student t[3] = {
    			{
    				//t[0]是一个结构体,肯定要符合结构体的初始化
    				2,
    				"zhangfei",
    				60,
    				{
    					1990,
    					2,
    					19
    				}
    				
    			},//t[0]
    			{
    				//t[1]是一个结构体,肯定要符合结构体的初始化
    				.name = "lisi",
    				
    				.birth = {
    					1990,
    					12,
    					9
    				}
    			},//t[1]
    			{
    				10,
    				"liubei",
    				70,
    				{
    					1991,
    					3,
    					4
    				}
    				
    			}//t[2]
    		
    		};
    		
    练习:
    	1,定义一个结构体数组(如:表示5个学生的结构体数组),对他初始化,并且一一打印出来
    		1,第一步要定义类型
    		2,有了类型之后,才能定义这个类型的变量
    		
    		交换t[0]和t[4]的信息。
    		struct student a;
    		a = t[0];
    		t[0] = t[4]
    		t[4] = a;
    		
    
    结构体支持整体赋值,没有必要一个一个成员变量去赋值
    	struct student a = {.....};
    	struct student b;
    	b = a;
    		
    	2,把这个结构体数组按照某个成员变量的值进行排序  《-作业
    

    2,共用体(联合体)
    union 共用体名
    {
    共用体成员变量1类型 共用体成员变量1名;
    共用体成员变量1类型 共用体成员变量1名;
    …根据实际情况决定有多少个成员变量
    };
    共用体和结构体的最大区别:
    结构体所占内存大小是各成员变量之和(当然还需要考虑字节对齐)
    共用体是所有成员变量共用 一块内存。
    union test
    {
    int a;
    char b;
    };
    a占4个字节,b占1个字节。
    共用体所占内存大小是各成员变量所占内存空间最大的那个所占的内存大小
    union test 占4个字节
    共用体所有成员变量的首地址都是一样的

    共用体适合那种,各种成员变量不同时使用的情况!!!是为了节省存储空间考虑的
    
    例子:
    1,
    	union test
    	{
    		int a;
    		int b;
    	};
    	
    	union test t;
    	t.a = 1234;
    	
    	printf("%d\n",t,b);
    	
    2,
    	union test
    	{
    		int a;
    		char b;
    	};
    
    	union test t;
    	t.a = 0x11223344;
    		t.a  0x11  0x22  0x33  0x44		->大端
    		t.b  0x44  0x33  0x22  0x11		->小端
    		
    		
    	t.b = ?
    		0x11
    		0x44
    	
    	大小端模式
    		大端:内存的低地址存放数据的高位(高数据位,高字节)
    		小端:内存的高地址存放数据的高位(高数据位,低字节)
    

    3,枚举
    把该类型变量所有可能的值都列举出来
    有些情况下,一个变量的值,是在一定的范围内。
    int a;//代表方向:上下左右
    0代表上1代表下2代表左3代表右
    a=200;//如果不小心这样写了怎么办?

    -》
    	enum direction
    	{
    		UP,
    		DOWN,
    		LEFT,
    		RIGTH
    	};//定义了一个新的(枚举)类型,有四个值,也就是说这个类型的变量只能取这四个值
    	
    	enum direction a;//变量a,只有四个值up,down,,,,
    

    枚举值,在实现的时候是用整数来实现。
    UP DOWN LEFT RIGTH,是给我们人看的,但是在实现的时候,其实是用一个整数来表示的。
    分别对应0,1,2,3 《——在没有赋值的情况下
    a = UP;

    	a++;//UP的下一个值
    
    
    	enum direction
    	{
    		UP = 10,//在有赋值的情况下,从10开始,依次为11,12,13
    		DOWN,
    		LEFT,
    		RIGTH
    	};
    	
    	enum direction
    	{
    		UP,			->0
    		DOWN,		->1
    		LEFT=10,	->10
    		RIGTH		->11
    	};
    
    	enum direction
    	{
    		UP=5,		->5
    		DOWN,		->6
    		LEFT=10,	->10
    		RIGTH		->11
    	};
    
    我们c语言中是没有bool类型
    	enum bool
    	{
    		false,
    		true
    	}
    
    	enum bool b;
    

    4,typedef
    typedef的本质是把一个已有的类型取一个新的名字"别名"
    typedef 现有的类型名 新类型名(别名)
    typedef unsigned char u8;
    u8并不是一个新的类型,它只不过是类型char的别名,那么在用u8的时候,其实就是unsigned char

    	struct student
    	{
    		int num;//学号
    		char name[20];//姓名
    		float score;//成绩
    		struct data birth;//出生年月日//成员变量可以是结构体
    	};
    	定义了一个新的类型:struct student
    	后面我们要用的时候,每次都有些struct student这么长,好麻烦
    	
    	typedef struct student STU;
    	把struct student这个类型取了一个别名:STU
    	
    	STU t;
    	struct student t1;//肯定可以啊,取了别名,还是可以用大名啊
    ----------------------------------------------------------
    	还可以在定义的时候就取别名
    	typedef struct student
    	{
    		int num;//学号
    		char name[20];//姓名
    		float score;//成绩
    		struct data birth;//出生年月日//成员变量可以是结构体
    	}STU;
    

    	typedef struct
    	{
    		int num;//学号
    		char name[20];//姓名
    		float score;//成绩
    		struct data birth;//出生年月日//成员变量可以是结构体
    	}STU;
    	//这样也可以,只取了别名,没有大名,不建议这么用
    

    我们c语言中是没有bool类型,我们可以用typedef和枚举创建一个bool类型
    
    	typedef enum bool
    	{
    		false,
    		true
    	}bool;
    
    	bool a;
    
    展开全文
  • C语言结构体

    2019-10-23 23:59:31
    结构体关键字struct。首先struct是一种数据类型,跟 char,int,double,等等一样。不过呢struct不同之处也是struct强大之处。它是一种特殊的“数组”。注意!!!是双引号的数组,而且是特殊的。 那么结构体与数组...

    初见结构体

    结构体关键字struct。首先struct是一种数据类型,跟 char,int,double,等等一样。不过呢struct不同之处也是struct强大之处。它是一种特殊的“数组”注意!!!是双引号的数组,而且是特殊的

    那么结构体与数组不同在哪呢?

    结构体与数组一样是一个容器。但是数组只能装同种类型的东西比如 int s[20];那么这个数组能放20个int。

    而结构体能放任何东西。一个struct里能放任何东西。而且struct是由你来定义,你想放什么就放,因此结构体非常灵活而又强大

     struct student
    {
    	int sno;
    	char sname[20];
    	char sex;
    	int age;
    	struct student* next;
    };  student是这个结构体的名字(结构体名),表明这是一个叫
        student的结构体。student结构体里能放大括号里类型的
        数据
        
    那么定义了student结构体怎么使用它呢?
    student s1;(s1是结构体变量名)
    就好了。结构体名跟int,double一样是数据类型的名字
    s1(结构体变量名)跟int a,double a里的a一样。

    初识结构体,很容易搞混结构体名结构体变量名的区别!仔细领会上面代码段的意思!!! 

    说到结构体就不得不提到typedef了。先看看同样的student结构体

    typedef struct student(结构体大名,正确的叫结构体名。这样说是为了便于理解)
    {
    	int sno;
    	char sname[20];
    	char sex;
    	int age;
    	struct student* next;
    }stu;(结构体小名)这个说法只是为了便于理解
    
    每次创建一个结构体变量时都要写
    student是不是很麻烦呢?
    通过typedef给student结构体取小名stu,
    接下来创建结构体变量就可以写成
    stu s1;了
    这就是typedef的妙用

    其实单单一个结构体非常地简单,到这里就可以算说完了。

    那么结构体哪里强大了呢???

    那就需要讲到一个叫链表的东西了。链表嘛,我放到下次再写O(∩_∩)O

     突然想到了一个东西,相同结构体名结构体变量(考验你是否分清这2东西的时候来了)可以互相赋值。也就是把=右边的结构体一一赋值给左边的结构体变量

    先开个头

    链表

    静态链表linklist

    虽然它的名字里有链表,但是在我看来静态链表是一个假链表。 首先在最开始我还是想再次强调一遍!!!

    结构体也是一种数据类型,跟int ,double,char等没有区别(int,double这些是基础类型,结构体是你自己设计的。差别就在这里)。

    数组是能存放有限个相同数据类型的容器。因此结构体数组就是能存放有限个结构体的容器。

    声明结构体数组

    接上面的例子继续
    (结构体名)stu  s(结构体变量名)[n](能装n个结构体的数组)
    
    
    

    我承认我想偷懒啦。因为结构体数组就是一个数组而已。所有数组怎么用,结构体数组就怎么用。

    但是有一点需要提一下结构体要用到的一个运算符  "."小点点运算符

    小点点能干啥呢?为什么需要小点点呢?

    众所周知,数组的索引下标可以取出数组中相应的元素。但是结构体里面至少含有一种基本类型

     

    我们的s[0]只是取出的s[0]上的结构体,但是我们需要的是里面的int a或者 char b(他们有个名字叫结构体成员)。这个时候就需要小点点了 

    比如我们需要给s[0]的int a赋值

    s[0].a=3

     小技巧,在定义了一个结构体后可以先编译一遍,这样的话在使用小点点访问结构体成员的时候会比较方便。(试了就知道了)


    插入一条水平线那么这周就是真正的链表了(linklist)2019.10.30

    动态链表

    动态链表与静态链表最大的区别就在于,动态链表在内存中的分配是不连续的。结构体数组也是数组,所有在内存中的分配是连续的。

    链表是由一个个结构体构成的,链表的结构体由2个部分组成

    1.数据域(负责存储数据)

    2.指针域(负责链接下一个结构体)

    typedef struct student
    {
            数据域存储数据
    	int no;
    	char name[20];
    	char gender;
    	int age;
            指针域的指针指向下一个student结构体
    	struct student* next;
    }stu;

    在上上涨图中,窝标了一个phead指针,它是链表火车的火车头。我们需要时刻掌握火车头的位置。一旦丢失了火车头的位置,那么这列火车就会消失在内存中。(这就是单向链表的缺点->因为每节车厢的指针只是指向下一节火车。换句话说,作为火车长的你只能从火车头一路走下去直到火车尾)。

    那么怎么创建一个链表呢?我们先来一个简单的代码来理解一下链表的基本思想

    在这之前先讲讲一个新的运算符(->)小箭头运算符。小箭头和小点点的作用一样,只是他们适用的对象不同。比如一个是国外旅游团导游,一个国内旅游团导游一样。小点点是结构体名的向导,小箭头是指向结构体的指针的向导。

    #include<string.h>	
    typedef struct student
    {
    	int sno;
    	char name[20];
    	char sex;
    	int age; 
    	struct student *next;  定义数据项,它是指向struct student类型的指针变量
    }stu;
    
    int main()
    { 
    	stu s1;           
    	s1.sno=1001;              这里的s1是结构体名,所以小点点导游
    	strcpy(s1.name,"smith");  负责带咱们访问s1结构体的成员
    	s1.sex='M';
    	s1.age=18;
    	s1.next=NULL;  赋值空指针
    	
    	stu s2; 
    	s2.sno=2002;
    	strcpy(s2.name,"angel");
    	s2.sex='F';
    	s2.age=28;
    	s2.next=NULL; 赋值空指针
    	
    	stu *p;
    	p=&s1;  这里p是指向s1结构体的指针
                    所以小箭头来负责带我们访问s1的结构体成员
    	stu *q;                    跟着箭头看下去         |     
    	q=&s2;                                           |
                                                             |
    	printf("学号    姓名    性别    年龄 \n");        |
    	printf("-----------------------------\n");       V
    	printf("%d\t%s\t%c\t%d\n",p->sno,p->name,p->sex,p->age); 
    	printf("%d\t%s\t%c\t%d\n",q->sno,q->name,q->sex,q->age);
    
    
        //下面看看 p->next是指针变量,但其值是啥?
        printf("p->next的值:%d\n",p->next); //结果是0,空指针(NULL)
        printf("q->next的值:%d\n",q->next); //结果是0,空指针(NULL)
    
        //将q指向的学生链接在p指向学生的后面,这样操作:
         p->next=q;  //朋友,你能画画吗?
    
     //下面再看看 p->next是指针变量,但其值是啥?q指针的值是啥?
        printf("\n"); 
        printf("p->next的值:%d\n",p->next); //有值!  到底是啥?
        printf("q的值:%d\n",q); //p->next与q的值相同!!链接上啦~~
    
     
        //我们验证下,两个学生到底链接上否?
        //只要通过p能够访问q指向的学生,就说明两个学生链接上啦!
         printf("\n"); 
         //通过p访问q所指向的学生,而没有使用q,你说两个学生链接上否?
         printf("%d\t%s\t%c\t%d\n",p->next->sno,p->next->name,p->next->sex,p->next->age)
      	
    	return 0;
    }
    
     

    理解了基本思想以后就到下一步了。一般建立链表都是写在自定义函数的。既然是自定义函数那么就各有各的写法了。

    接下来是我自己的链表创建的自定义函数。并会在后面较详细的说明我的想法

    声明结构体 
    typedef struct student
    {
    	int no;
    	char name[20];
    	char gender;
    	int age; 
    	struct student* next;
    }stu;
    存放LinkList的头尾指针 
    typedef struct List
    {
    	stu* head;
    	stu* node;
    }list;
    
    自定义函数
    void create(list* studentdata)
    {
    	int cnt;
    	printf("输入学生数据个数:");scanf("%d",&cnt);
    	for(int i=0;i<cnt;i++)
    	{
    		printf("输入第%d个学生数据\n",i+1);
    		stu* p=(stu*)malloc(sizeof(stu));
    		printf("no:");scanf("%d",&(p->no));fflush(stdin);
    		printf("name:");gets(p->name);
    		printf("gender:");(p->gender)=getchar();
    		printf("age:");scanf("%d",&(p->age));
    		p->next=NULL;
    		if(i==0)
    		{
    			studentdata->head=p;
    			studentdata->node=p;
    		}
    		else
    		{
    			studentdata->node->next=p;
    			studentdata->node=p;
    		}
    	}
    }
    
    

     除了存储数据的主体student结构体,还用了一个list结构体来存储链表的头尾指针。使用list结构体来管理链表的指针或者其他数据是有优越性的。list就像一个管家,任何关于链表的数据都可以存储在list结构体里。例如链表的节点个数。只需要在list结构体里增加一个int count就好了。

    但是有一个问题出现!

    相信你也发现了,在create函数里,我们同样需要先输入一个n来确定循环的次数。那这跟使用结构体数组又有啥区别呢?

     我觉得这是一个灵魂拷问!但是他们也有一个不同点就是在内存中的分配空间。结构体数组是连续的,链表是不连续的。因此在内存中的分配更加灵活有效率。

    可是这并没有解决最初的问题!?有没有办法能够不预先输入一个n,而是输入到你想停止的时候就结束链表的create呢?

    那么用while呢?那么就需要每回输入一个标志来进入while,这反而比for更麻烦了。那么能使用的循环都用完了呀。说到这里,你是否觉得我要说出一个天才方案来实现呢?很遗憾,经过短暂的思考就我的水平来说,我觉得是无解的。

    但是这不能说链表与结构体数组一样,他们还是有差别的。我上面就列出来了,不要小看这一点点区别。链表因为在内存中分配更灵活,可以建立更多的节点。直白来说就是可以存储更多个学生的数据。

     

     

    展开全文
  • 3、在C语言中 * 有3个含义:a * b =c //乘 int *p //声明p是一个整型类型的指针(理解时从右向左) * p //指向 4、指针有两个值:自身的值和指向的值 5、*ip 指向b, 就是对b的操作。 6、指针的大小 (double 类型) 和...

    指针
    在这里插入图片描述

    1、指针是地址,指针变量即是地址变量。
    2、通过指针改变变量a的值
    int main()
    {

    int a=10;
     int *p=null;
     p=&a;
     *p=100;
     return 0; }
    

    3、

    在C语言中 * 有3个含义:a * b =c //乘
    int *p //声明 p是一个整型类型的指针(理解时从右向左)
    * p //指向
    4、指针有两个值:自身的值和指向的值
    5、*ip 指向b, 就是对b的操作。
    6、指针的大小 (double 类型) 和编译器所选的环境有关
    win32->32bit->4
    x64 ->64bit->8
    7、定义指针变量时,类型对指针变量起2个作用。A 解析存储单元的大小,B、指针变量+1的能力。
    8、指针值传递。
    9、空指针 :int *ip = NULL;
    野指针:int *ip ;
    10、指针类型不同+1 的能力也不一样。int 类型指针加1即是地址+4;char 类型指针+1指针地址+1;
    即:typename *ip;
    ip = ip+1;//ip =ip+ sizeof(typename)*1
    11、指针和整型加减结果仍是指针类型。
    结构体
    7.结构体:一种数据类型

     Struct  Student
      {
      char   s_id[10];
      char   s_name[20];
      int s_age;
      };
      int main()
      {
        //定义变量
      int a=10;
      Struct Student x={"20201","li",19}//输出打印
      printf("%d",a);
      printf("id: %s\n",x.id);
      }
      **输入与输出**
     

    8、printf 就是向这个文件件输出数据 stdout(标准输出)->显示器;
    scanf 就是从这个文件读取数据 stdin(标准输入)->键盘
    stderr(标准错误文件):无缓冲,会直接输出;printf 会先在行缓冲,在输出。
    typedef
    9、typedef : 把一切合法的变量名的定义或声明通过typedef 转换成一个类型名。
    在这里插入图片描述

    10、typedef int *PIN
    PIN a,b; === int *a,*b;
    11、typedef 与#define PIN int *的区别
    12、typedef 定义简单的别名

    typedef Struct Student { char s_id[10]; char s_name[20]; int s_age; }Stuyn; 等价

     Struct  Student
      {
      char   s_id[10];
      char   s_name[20];
      int s_age;
      };
      typedef  Struct Student Stuyn;
    

    Static
    13、当函数内的变量加上static 关键字后,他从栈区移到了数据区(.data),它的生存周期不受函数的影响。

     int fun ()
      {
      int a=0;//a,b 变量在栈区,当函数结束会被释放
      int b=0;
      ++a;
      ++b;
      printf("%d%d",a,b);
      }
      int main()
      {
      int i=1;
      while(i<5)
      {
      fun();
      i++;
      return 0;
      }
    

    当加上 static int a =0 时,a被放在了数据区,它的生存周期不受fun函数的影响。
    静态关键字修饰局部变量 :可见性不变,生存期改变到在.data区;修饰全局变量:可见性变为本文件,生存期不变在.data区
    extern :全局变量和函数在另一个文件中使用给出的声明。
    const
    const 定义的变量是常变量。是可读不可写。只具有右值性质不具有左值性质。
    const可以修饰变量,也可以修饰数组。不论是变量还是数组,加上const 的变量一定要初始化。只可读不能被修改。
    声明与定义
    声明不分配内存空间,定义分配了内存空间
    运算符的优先级
    赋值运算符<关系运算符<算术运算符
    “==”赋值运算符:将常量写在左边,变量写在右边,例如:
    if(2 == b) //常量可读不可写
    逻辑表达式 , 关系表达式
    运算结果是 bool 值
    “&&”与运算(简洁与):当第一个表达式为假时,不需要判断后面,直接得出为假;
    “||”或运算(简洁或):当第一个表达式为真时,不需要判断后面,直接得出为真;
    在所有的单目运算符中,只有“++,–”具有赋值能力。

    int main()
    {
    int a = 10;
    bool tag = false;
    tag = !!a;
    printf("%d %d",a,tag);
    return 0;
    }//a=10;tag=1;
    

    分支语句
    1、if 语句
    2、多分支语句
    3、空语句

    展开全文
  • C语言结构体学习总结

    万次阅读 多人点赞 2018-08-13 18:04:11
    今天,我们着重总结一下构造数据类型中的结构体关键字:struct,不能省略) 的相关知识。 1.什么是结构体结构体是一种工具,用这个工具可以定义自己的数据类型。同时,从上图可以看出结构体属于构造数据类型...

    C语言中包含short、int、long、char、float、double这六中基本数据类型。当然还有构造类型、指针类型、和空类型。如图所示:

    今天,我们着重总结一下构造数据类型中的结构体 (关键字:struct,不能省略) 的相关知识。

    1.什么是结构体?

    结构体是一种工具,用这个工具可以定义自己的数据类型。同时,从上图可以看出结构体属于构造数据类型。

    2.结构体与数组的比较

    (1)都由多个元素组成

    (2)各个元素在内存中的存储空间是连续的

    (3)数组中各个元素的数据类型相同,而结构体中的各个元素的数据类型可以不相同

    3.结构体的定义和使用

    (1)一般形式

    struct 结构体名 {
        类型名1 成员名1;  //成员类型可以是基本类型或构造型
        类型名2 成员名2;
        ...
        类型名n 成员名n;
    };    //注意不要忘记此处的;

    例如,我们要表示一个学生的个人基本信息。如 姓名、性别、年龄、分数等基本信息,我们则可以如下定义:

    struct Student{
        char name[10];
        char sex;
        int age;
        float score;
    };

    (2)定义结构体类型的变量、指针变量和数组

    定义结构体类型变量有以下三种方法,本人比较喜欢第三种。

    方法一:定义结构体类型时,同时定义该类型的变量

    struct [Student] {   /*[]表示结构体名是可选的*/
        char name[10];
        char sex;
        int age;
        float score;
    }stu1,*ps,stu[5]; /*定义结构体类型的普通变量,指针变量和数组*/

    方法二:先定义结构体类型,再定义该类型的变量

    struct Student {   /*[]表示结构体名是可选的*/
        char name[10];
        char sex;
        int age;
        float score;
    };
    
    struct Student stu1,*ps,stu[5]; /*定义结构体类型的普通变量,指针变量和数组*/

    方法三:用类型定义符typedef先给结构体类型名别名,再用别名定义变量

    typedef struct [Student] {
        char name[10];
        char sex;
        int age;
        float score;
    }Stu;
    Stu stu1,*ps,stu[5]; /*用别名定义结构体类型的普通变量,指针变量和数组*/

    说明:

    结构体类型与结构体变量概念不同。

    1.类型:不分配内存;变量:分配内存;

    2.类型:不能赋值、存取、运算;变量:可以;

    3.结构体可以嵌套;

    4.结构体成员名与程序中变量名可相同,不会混淆。

    例如:

    struct date{
        int month;
        int year;
    
    };
    
    
    struct student{
        int num;
        char name[20];
        struct date birthday;  /*结构体可嵌套*/
    
    }Stu;

    (3)给结构体变量赋初值

    一般格式:结构体类型 结构体变量名 = {初始表值};

    方法一:

     struct [Student] {
        char name[10];
        char sex;
        int age;
        float score;
    }stu[2]={{"ZhangSan",'F',22,90},{"Su",'M',20,85}};

    方法二:

    struct student{
        char name[10];
        int age;
        float score[5],ave;
    };
    
    struct student  Stu = {"ZhangSan",22,99,78,99,76,88};

    注:ANSI C允许两个相同结构的结构体变量直接赋值

    struct student li,zhang = {"zhang",20,92,90,98,67,0};
           li=zhang;  //将zhang对象拷贝一份赋值给li
                /*但 li = {"li",19,76,56,90,69,80};是非法的*/
    

    (4)引用结构体变量中的成员

    a.结构体变量名·成员名:stu1.name

    b.结构体指针变量—>成员名:ps—>name

    c.(*结构体指针变量).成员名:(*ps).name

    d.结构体变量数组名.成员名:stu[0].name

    注:1.求结构体类型数据的字节数

    sizeof(变量名或类型名);

    2.嵌套结构体中成员的引用

    结构体嵌套时,逐级引用

    struct student{
        int num;
        char name[20];
        struct date{
            int month;
            int day;
            int year;
        }Birthday;
    
    }stu1,stu2;
    
    
    //给出生日期的年份赋值
    stu1.Btrthday.year = 1999;

    4.结构体指针变量的定义和引用

    1.结构体指针变量的定义

    定义形式:struct 结构体名 *结构体指针名;

    struct student *p;  //此时指针变量*p中存放的是----结构体变量在内存的起始地址
    
    
    //例:
    
    struct student{
        int num;
        char name[20];
        char sex;
        int age;
    }Stu;
    struct student *p = &Stu;
    

    2.结构体指针变量的引用

    使用结构体指针变量引用成员形式

    (*结构体指针变量名).成员名 <=> 结构体指针变量名—>成员名 <=> 结构体变量名.成员名(<=>是等价符号哈,各位看官莫慌=_=!)

    例:

    int n;
    int *p = &n;
    *p = 10; <=> n = 10;
    struct student{
        long int num;
        char name[20];
        char sex;
        float score;
    }Stu1;
    
    struct student *p = &Stu1;
    
    Stu1.num = 10; <=> (*p).num = 101; <=>p —>num = 101;

     

    5.用结构体类型和基本数据类型的定义变量的对比

     

    注:感谢博主 I come,I conquer  的博文帮助,附上原文地址:https://www.cnblogs.com/JCSU/articles/1487302.html

     

    展开全文
  • C语言结构体和结构体排序

    千次阅读 多人点赞 2019-01-26 22:06:48
    (构造数据类型包括:数组类型、结构体类型、共用体类型) 定义:把不同的数据组合成一个整体。 结构体的一般形式 struct [结构体名称]//struct是关键字 { 类型标识符 成员名;//成员类型可以是基本型或构造性 ...
  • C语言结构体(数据结构中的应用) 在学习数据结构的时候,才发觉自己C语言已经忘得差不多了,连结构体都不太晓得怎么写了,特来补习。 结构体”这个词是根据英文单词 structure 译出的。 所以结构体的关键字是 ...
  • 文章目录结构体,联合体,枚举相应的关键字结构体typedef关键字结构体的声明定义的使用方法:结构体的初始化方法:结构体变量成员(字段)的访问函数和结构体,函数的形参联合体枚举C语言函数指针及多级指针 ...
  • C语言 结构体定义

    2021-03-28 19:29:51
    为什么要用结构体 ...关键字: struct struct Student //注意没括号 { int score; char name; void (introduce)(char *pname); }; //一定要注意分号!!!!! 类型 变量名 初始值 int a = 10 struct Student
  • C语言 结构体

    2020-09-05 14:07:48
    1)结构体的定义(关键字 struct) struct student(结构体名) { int No; //成员类型 成员名 char name[256]; } 创建一个结构体 struct student std;(如果结构体中存在使用指针的,需要申请...
  • C语言结构体的应用

    千次阅读 2019-04-02 10:36:08
    1.结构体 (1)结构体声明 结构体可以用来给C语言增加...struct 结构体类型名{ 结构体成员类型 成员变量名; ....... }; 结构体声明语法中的成员变量不可以初始化,因为结构体声明不分配内存 可以在声明结构体是同...
  • C语言结构体变量

    2019-07-08 16:06:41
    结构体变量的定义 ...struct为结构体关键字,student就是这结构体类型名,而 num,name, score就是该结构体的成员,他们可以是不同类型的,注意在定义类型的时候不要对结构体成员num,name, ...
  • 结构体_结构体指针,typedef结构体定义#define _CRT_SECURE_NO_WARNINGS#include #include #include #include //上面的头文件 下面几个例子都要有//结构体 关键字 struct//结构体是一种构造数据类型//把不同的数据...
  • C语言结构体类型是由不同的类型的数据组成的,组成结构体类型的每一个数据都称为该结构体类型的成员。在程序设计中,使用结构体时,首先要对结构体类型的组成进行描述,结构体的定义方式如下:struct 结构体类型...
  • C语言中的关键字

    2015-03-17 16:18:00
    1.C语言中的关键字都有实际的意义。 2.C语言中的23个关键字如下: char:声明字符型变量。 short:声明短整型变量。 int:声明整型变量。 long:声明长整型变量。 float:声明浮点型变量。 double:声明双精度型...
  • 一、结构体基本概念 ... 声明一个结构体类型的一般形式为: struct Student { char id[8]; char name[10]; char sex[4]; int age; }; 其中,struct为结构体关键字,Student为结构体名,成...
  • //struct结构体关键字 //创建一个学生类型Stu struct Stu { char name[20]; short age; }; int main() { struct Stu s1 = { "张三",30 }; //s1是结构体对象 printf("%s %d\n", s1.name, s1.age); //结构体
  • c语言结构体理解

    2020-06-16 17:32:45
    其实我们定义结构体就可以看作定义一个新的数据类型来满足我们的需求。 我们都知道变量的定义是 type variable; 如果我们 struct A{ int i; } A就是结构体名(也可以说标签),{ int i; }就是结构体大小. ...
  • 1.声明一个结构体类型 格式:关键字 结构体名 {成员列表}; 成员可以是c语言中任意合法的数据类型。 普通结构体类型声明 ... typedef 关键字结构体类型声明 typedef struct struct_name{ ...
  • c语言结构体一篇懂

    2021-06-12 03:44:33
    struct结构体关键字1——什么是结构体2——结构体定义形式与细节3——结构体变量4——结构体的存储5——成员的获取与赋值6——位段7——位段的存储 1——什么是结构体 它是一种可以由多种类型数据或单种类型创建的...
  • C语言中,定义结构体变量要在结构体类型名前加关键字struct,而C++也保留了这一用法,例: struct Student student1, student2; 但C++语言也提出了新的方法,即在定义结构体变量时,不需要加关键词struct。 (2)在...
  • ### 结构体_结构体指针,tyepdef结构体定义 #define _CRT_SECURE_NO_WARNINGS #include <...//上面的头文件 下面几个例子都要有//结构体 关键字 struct //结构体是一种构造数据类型 //把不同的数据类型
  • C语言结构体内存对齐

    2020-03-22 18:10:51
    struct关键字的功能是将不同的数据类型封装起来,抽象成一个整体使用。 空结构体 结构体所占的内存大小是其成员所占内存之和,但如果我们定义了一个空的结构体,那么它的大小是多少?考虑下面的这种情况: typedef ...
  • C语言32个关键字

    2021-05-03 10:43:43
    关键字 说明 auto 声明自动变量 short 声明短整型变量或函数 int 声明整型变量或函数 long 声明长整型变量或函数 float 声明浮点型变量或函数 double 声明双精度变量或函数 char 声明字符型变量或...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 761
精华内容 304
关键字:

c语言结构体类型关键字

c语言 订阅