Technology sharing

C language - structure

2024-07-12

한어Русский языкEnglishFrançaisIndonesianSanskrit日本語DeutschPortuguêsΕλληνικάespañolItalianoSuomalainenLatina

1. Definire et uti structurae

1.1 Overview

Datae rationes quas ante vidimus, ut int, supernatet, char, etc., simpliciter in programmatibus adhibita sunt.

Exempli causa, discipulus discipulus numerus, nomen, genus, aetas, etc. ad eundem discipulum pertinent, sed hae variabiles ad diversas rationes pertinent . Inde variabile creamus, quod notitias istas miscere potest et in variabile ponemus, ut multo simplicius utatur.

  1. 结构体类型：
  2.         struct Student
  3.         {
  4.               int num;//学号为整形；
  5.               char name[20];//姓名为字符串；
  6.               char sex;//性别为字符型；
  7.               int age;//年龄为整形
  8.               float score;//成绩为浮点型
  9.               char addr[30];//地址为字符型；
  10.         }

in:

strue Discipulus est genus structurae;

struit keyword quod declarat structuram genus.

Studiosum nomen est structurae, ut ab aliis structuris distinguatur;

Bracteae crispae membra structurae continent. Coetus simul membrum album appellatur, et nominatio variabilium congruens est;

Nota: Structurae rationes plures habere possunt;

Membra structurae etiam generis alterius structurae esse possunt;

instruere Date

{        

int mensis;

int diem;

int annum;

};

instrúite Student

{

int num;

char name[20];

sexus char;

int aevum;

Date natalem struct;

char addr[30];

}

1.2 Definitio structurae variabilium

Ante solum genus structuram definivimus, quae exemplari aequiparatur, nec variabiles definimus.

Modus I: Annuntiate genus structurae primum, et deinde variabilium structuram definire

Studiosum in structuram priorem structura genus fundatur, structuram variabilium definiunt;

instrúite Discipulus discipulus1, discipulus2;

Haec methodus similis est int a, b; unum necessarium est, ut iam structurae genus sit, et structura variabilis secundum rationem definitur.

    Modus II: Define variables dum declarans genus

formare;

nomen instruere structuram

                {

membrum album;

} Variabile nomen album;

Exemplum:

instrúite Student
                {
int num;
char name[20];
sexus char;
int aevum;
supernatet viginti;
char addr[30];
} student1, student2;

      Modus III: Directe definias structuram genus variabilium sine ratione generis nomen

formare;

struct

                        {

Socius variabilis;

} Variabile nomen album;

Est typus structurae innominatae et non vulgariter adhibetur;

Nota: 1. Sodalis nomina in structura variabilium eadem esse possunt ac nomina variabilium in programmatis;

2. Sodales structurarum variabiles soli adhiberi possunt;

1,3 Initialization and reference of structure variables

Initialize variabiles structurae eas definientes;

      Exemplum:Indicium discipulorum pone (including numerum studiosum, nomen, genus, electronicam) in structura variabili, et tunc outputa in notitia discipulorum;

  1. #include <stdio.h>
  2.  
  3. int main()
  4. {
  5. 	struct Student
  6. 	{
  7. 		int num;
  8. 		char name[20];
  9. 		char sex;
  10. 		char addr[20];
  11. 	}student1 = {101,"Li li",'M',"123XiAn"};
  12. 	printf("NO:%d,nname:%snssex:%cnaddress:%sn",student1.num,student1.name,student1.sex,student1.addr);
  13. 	return 0;

Proventus analysis:

Cum variam structuram definiat, membra eius obiter initializationem indicem numerorum constantium in capreolis crispis inclusit structuram.

Valor sodalis in structura variabilis, modus referendi est:

Structura variabilis name.Member nomine

student1.name

      Ad structuram membrorum quae ad alterius generis structuram pertinent, membra infima gradu gradu invenienda sunt.

Discipulus natalis.month

Eiusdem generis structurae inter se assignari possunt;student1= student2；

        Exemplum:Discipulum ID intrant, nomen et gradus duorum studentium, et output studiosum ID, nomen et gradus studentis cum superioribus gradibus;

  1. #define _CRT_SECURE_NO_WARNINGS
  2. #include <stdio.h>
  3.  
  4. int main()
  5. {
  6. 	struct Student
  7. 	{
  8. 		int num;
  9. 		char name[20];
  10. 		float score;
  11. 	}student1,student2;
  12. 	scanf("%d%s%f", &student1.num, student1.name, &student1.score);
  13. 	scanf("%d%s%f", &student2.num, student2.name, &student2.score);
  14. 	printf("The higher score is:n");
  15. 	if (student1.score > student2.score)
  16. 	{
  17. 		printf("%d %s %6.2fn", student1.num, student1.name, student1.score);
  18. 	}
  19. 	else if (student1.score < student2.score)
  20. 	{
  21. 		printf("%d %s %6.2fn", student2.num, student2.name, student2.score);
  22. 	}
  23. 	else
  24. 	{
  25. 		printf("%d %s %6.2fn", student1.num, student1.name, student1.score);
  26. 		printf("%d %s %6.2fn", student2.num, student2.name, student2.score);
  27. 	}
  28. }

Cum scanf functione utens ad variabiles structuras inputandas, eas separatim inicere debes de student1.name, quia nomen ordinata originaliter repraesentat Got inscriptionem.

2. Usus structuram ordinata

2.1 Definire structuram ordinata

Cum ante definivimus structuras variabiles, eas singillatim definivimus. Sed, si est coetus notitiarum relativarum quae operationem participare debet, patet notitia uti necesse est, ut indicio 10 discipulorum structura ordinata est.

Exempli gratia: Tres sunt candidati, et quilibet suffragator unum tantum suffragium ferre potest. Oportet rationem scribere suffragiorum computandi.

  1. #define _CRT_SECURE_NO_WARNINGS
  2. #include <stdio.h>
  3. #include <string.h>
  4.  
  5. struct Person
  6. {
  7. 	char name[20];
  8. 	int count;
  9. }leader[3] = { "wang", 0, "zhang", 0, "li", 0 };
  10. int main()
  11. {
  12. 		int i, j;
  13. 		char lead_name[20];
  14. 		for (i = 0; i < 10; i++)
  15. 		{
  16. 			scanf("%s", lead_name);
  17. 			for (j = 0; j < 3; j++)
  18. 			{
  19. 				if (strcmp(lead_name, leader[j].name) == 0)
  20. 					leader[j].count++;
  21. 			}
  22. 		}
  23. 		printf("nResultn");
  24. 		for (i = 0; i < 3; i++)
  25. 		{
  26. 			printf("name:%s,count:%dn", leader[i].name, leader[i].count);
  27. 		}
  28. 		return 0;
  29. 	}

Definire formam communem structurae ordinatae:

        nomen instruere structuram

        {

variabilis index

nomen ordinatae [orna longitudo];

or *

Primum genus structuram declarant, ut: studiosum instruere, et deinde structuram definire;

        Structura type ordinata nomen [disposita longitudinis];

Forma initialis structurae ordinata est post definitionem addere;

      ={Index valoris initialis};     

2.2 Using structure ordinata

        Exemplum:Investigatio de n studentibus (including student ID, nomen et gradus), requiritur informationem cuiusque studentis in ordine gradus ponere;

  1. #define _CRT_SECURE_NO_WARNINGS
  2. #include <stdio.h>
  3. #include <string.h>
  4.  
  5. struct Student
  6. {
  7. 	int num;
  8. 	char name[20];
  9. 	float score;
  10. };
  11.  
  12. int main()
  13. {
  14. 	struct Student stu[5] = { 1001, "Wangwei", 98.25, 1002, "Liuliu", 91, 1003, "Zhangli", 98, 1004, "Xiaozhao", 85, 1005, "Baibai", 94 };
  15. 	struct Student temp;
  16. 	printf("The order id:n");
  17. 	int i, j,k;
  18. 	for (i = 0; i < 4; i++)
  19. 	{
  20. 		k = i;
  21. 		for (j = i + 1; j < 5; j++)
  22. 		{
  23. 			if (stu[j].score>stu[k].score)
  24. 			{
  25. 				k = j;
  26. 			}
  27. 		}
  28. 			temp = stu[k]; 
  29. 			stu[k] = stu[i]; 
  30. 			stu[i] = temp;	
  31. 	}
  32. 	for (i = 0; i < 5; i++)
  33. 	{
  34. 		printf("%d  %s  %5.2f", stu[i].num, stu[i].name, stu[i].score);
  35. 		printf("n");
  36. 	}
  37. 	return 0;
  38. }

3. structura monstratorem

3.1 Indicis ad structuram variabilium

Sic dicta monstrator structurae monstratorem est variabilis structurae. Incipiens inscriptio structurae variabilis est regula variabilis structurae.

Regula variabilis demonstrans ad rem structuram vel structuram variabilem vel elementum structurae ordinatae demonstrare potest. Basis regulae variabilis ratio idem esse debet ac genus structurae variabilis.

Verbi gratia: struct Student *pt;

Exemplum:Informationes membrorum in structura variabilis per regulam variabilem monstrat structurae variabilis;

  1. #define _CRT_SECURE_NO_WARNINGS
  2. #include <stdio.h>
  3. #include <string.h>
  4.  
  5. struct Student
  6. {
  7. 	long num; 
  8. 	char name[20];
  9. 	char sex;
  10. 	float score;
  11. };
  12.  
  13. int main()
  14. {
  15. 	struct Student stu1;
  16. 	struct Student *pt;
  17. 	pt = &stu1;
  18. 	stu1.num = 10001;
  19. 	strcpy(stu1.name, "Lili");
  20. 	stu1.sex = 'M';
  21. 	stu1.score = 96.5;
  22. 	printf("No:%dnname:%snsex:%cnscore:%5.1fn", stu1.num, stu1.name, stu1.sex, stu1.score);
  23. 	printf("n");
  24. 	printf("No:%dnname:%snsex:%cnscore:%5.1fn", (*pt).num, (*pt).name, (*pt).sex, (*pt).score);
  25. 	printf("n");
  26. 	printf("No:%dnname:%snsex:%cnscore:%5.1fn", pt->num, pt->name, pt->sex, pt->score);
  27. 	return 0;
  28. }

Proventus analysis:

In munere, accessiones primae printf functionis membra per structuram nominis variabilis stu1;

Secunda impressio functionis eius membris accedit per regulam variabilem ad structuram variabilem demonstrans.

Praeterea in C lingua reponere licet (*pt).num cum num;

3.2 Indicium ad structuram ordinata

Regulae variabiles adhiberi possunt ad designandum elementa structurae ordinatae.

Exemplum:Tres sunt informationes studentium, in structura ordinatae, et informatio discipulorum debet esse output;

  1. #define _CRT_SECURE_NO_WARNINGS
  2. #include <stdio.h>
  3. #include <string.h>
  4.  
  5. struct Student
  6. {
  7. 	long num; 
  8. 	char name[20];
  9. 	char sex;
  10. 	float score;
  11. };
  12.  
  13. int main()
  14. {
  15. 	struct Student stu[3] = { 1001, "wangle", 'M', 95, 1002, "chengcai", 'M', 99.9, 1003, "shangmin", 'F', 85.2 };
  16. 	struct Student *pt;
  17. 	printf("No.  name       sex  scoren");
  18. 	for (pt = stu; pt < stu + 3; pt++)
  19. 	{
  20. 		printf("%d %s %c %5.2fn", pt->num, pt->name, pt->sex, pt->score);
  21. 	}
  22. 	return 0;
  23. }

In programmatis, pt monstrator est ad structuram struct Discipulus variabilis. Ponitur structurae variabilis, non cuidam membri structurae structura variabilis et altera structura membrum variabile est. p++, valor ipsius p longitudinem structurae auget.

3

Tribus modis efficiunt valorem structurae variae ad functionem;

1. Utere membra structurarum variabilium pro parametris. Haec methodus aequivalet ordinariis variabilibus transeundi.

2. Variabiles structurae uti parametri actuales. Cum structura variabilis ut parametri actualis adhibeatur, etiam pretii transit.

3. Utere monstratorem ad structuram variabilem (compositam) ut parametri actualis, ut oratio structurae variabilis (ordinata) ad modulum formalem transeat.

Exemplum:

N structurae sunt, inter discipulorum IDs, nomina, et gradus in tribus ordinibus. .

  1. #define _CRT_SECURE_NO_WARNINGS
  2. #include <stdio.h>
  3. #include <string.h>
  4. void print(struct Student stud);
  5. struct Student Max(struct Student stu[]);
  6. void input(struct Student stu[]);
  7. struct Student
  8. {
  9. 	int num; 
  10. 	char name[20];
  11. 	float score[3];
  12. 	float aver;
  13. };
  14.  
  15. int main()
  16. {
  17. 	struct Student stu[3], *pt;
  18. 	pt = stu;
  19. 	input(pt);
  20. 	print(Max(pt));
  21. 	return 0;
  22. }
  23. void input(struct Student stu[])
  24. {
  25. 	int i;
  26. 	printf("请输入各学生的信息：学号、姓名、3门成绩：n");
  27. 	for (i = 0; i < 3;i++)
  28. 	{
  29. 		scanf("%d%s%f%f%f", &stu[i].num, stu[i].name, &stu[i].score[0], &stu[i].score[1], &stu[i].score[2]);
  30. 		stu[i].aver = (stu[i].score[0] + stu[i].score[1] + stu[i].score[2]) / 3.0;	
  31. 	}
  32. }
  33.  
  34. struct Student Max(struct Student stu[])
  35. {
  36. 	int i, m = 0;
  37. 	for (i = 0; i < 3; i++)
  38. 	{
  39. 		if (stu[i].aver > stu[m].aver)
  40. 			m = i;
  41. 	}
  42. 	return  stu[m];
  43. }
  44. void print(struct Student stud)
  45. {
  46. 	printf("成绩最好的学生是：n");
  47. 	printf("学号：%d 姓名：%s 三门课程：%5.2f %5.2f %5.2f平均成绩：%5.2fn", stud.num, stud.name, stud.score[0], stud.score[1], stud.score[2], stud.aver);
  48. }

1. Cum munus input vocans, parameter actualis est regula variabilis pt, et parameter formalis est structura ordinata.

2. Cum munus Max vocatum, parameter actualis est regula variabilis pt, parameter formalis est structura ordinata, principium structurae elementi inscriptio redditur, et munus reditus pretii structura speciei data est.

3. Cum vocans munus print, actuales parametri structurae variabiles sunt (structurae elementa ordinata), et parametri formales variabiles structurae sunt.

4. Coniunctum album

4.1 Overview

Index coniunctus communis notitiae structurae est, quae structuram destinatio dynamicae repono.

Cum accommodare notitias in ordine, ordinatae longitudo (multa vestis) ante definiri debet. Si aliquae lectiones 100 studentes et aliquae classes 30 studentes habeant, si eadem ordinata notitia studiosorum in diversis generibus congregentur, illud est. Definiendum est. Ordinata cum longitudine 100, sed hoc saepe in vastitatem opum ducit.

Index coniunctus variam habet "capitis regulam", quae per caput in figura repraesentat, quae electronicam demonstrat elementum.

1. Actualis notitia requiritur ab utentibus;

2. Oratio sequentis elementi;

Perspici potest inscriptiones uniuscuiusque elementi in indice coniuncto in memoria posse esse discontinuos. Ad elementum quoddam inveniendum, primum elementum prius inveneris, deinde elementum inveniri potest ex inscriptione prioris elementi. . Si "montorium capitis" non praebetur, totum indicem coniunctum inaccessibilis est.

Hoc in casu, aptissimum est structuram uti indicem coniunctum aedificare. Structura plura membra continet, et regulae typus membra condere electronicam nodi proximi adhibentur.

instrúite Student

        {

int num;

int score;

struct Student * next;

        }

Apud eos, num et octoginta sunt notitiae usoris ad reponendas, et deinde ad electronicam nodi sequentis reponendam adhibetur.

4.2 Static coniunctum album

Causa:

Album coniunctum static crea in nodis constans cum notitia trium studentium, et notitias cuiusque nodi ad outputandum require;

  1. #define _CRT_SECURE_NO_WARNINGS
  2. #include <stdio.h>
  3.  
  4. struct Student
  5. {
  6. 	int num; 
  7. 	float score;
  8. 	struct Student * next;
  9. };
  10.  
  11. int main()
  12. {
  13. 	struct Student a, b, c, *head, *p;
  14. 	a.num = 1001; a.score = 85.5;
  15. 	b.num = 1002; b.score = 95.5;
  16. 	c.num = 1003; c.score = 84.5;
  17. 	head = &a;
  18. 	a.next = &b;
  19. 	b.next = &c;
  20. 	c.next = NULL;
  21. 	p = head;
  22. 	do
  23. 	{
  24. 		printf("%d %5.2fn", p->num, p->score);
  25. 		p = p->next;
  26. 	} while (p != NULL);
  27. 	return 0;
  28. }

Exempli causa, album coniunctum crea ut caput nodi a, a.nex puncta ad nodi b, b. dein puncta ad nodi c, et c. dein puncta ad nullum.

Cum indice coniuncto extrahendo, prius p utere debes, p punctum ad a fac, deinde notitias in a.

4.3 Dynamic coniunctum album

4.3.1 Dynamic memoria destinatio

Priusquam de actis dynamicis dicamus, primum ad dynamicam memoriam destinatio vobis introducamus.

Prius diximus variabiles in global variabiles et variabiles locales divisae. Variabiles rerum in static tabularium memoriae collocari memoriaBIBLIOTHECA。

Insuper lingua C etiam permittit ut areas dynamicae memoriae destinatio ad aliqua temporanea congreget. Haec notitia aperiuntur quando opus est et emittitur quando non opus esttumulus。

Destinatio memoriae dynamica fit per functiones systematis instructas: malloc, calloc, munera gratuita et realloc.

1. Utere malloc munus aperire dynamicam tabularium

officium: void *malloc (unsigned int size);

Officium:

        Colligunt spatium continuum longitudinis (unitatis: bytes) in dynamica tabularia memoriae.

valorem reddere:

Inscriptio primae byte sortita est; haec inscriptio nullum habet genus, sed aperta oratio;

2. Utere ad munus calloc aperire dynamicam tabularium

officiumvoid * calloc(n, unsigned size);

Officium:

Collocat n bytes spatii continui cum longitudine magnitudinis in dynamica tabularia memoriae. Spatium hoc relative magnum est ad salvandum ordinem;

Utere munere calloco ad aperiendum spatium dynamicum repono spatium unius dimensionis ordinatae, n numerus est elementorum ordinata, et magnitudo est longitudo elementi.

valorem reddere:

Inscriptio primae byte sortita est; haec inscriptio nullum habet genus, sed aperta oratio;

3. utere realloc munus ad dynamicam tabularium reallocate

officium:void * realloc(void*p, unsigned int size);

Officium:

Reallocate memoriae dynamica collocari.

Revocato utere munere ad mutandam magnitudinem spatii dynamici per p ad magnitudinem demonstrati. Valor p mutatur;

valorem reddere:

Oratio primi byte memoriae dynamicae post adaequationem essentialiter est oratio a p.

4. Munus liberum utere ut dynamicam tabularium dimittere

officium: void free(void*p);

Officium:

Dimitte spatium dynamicum a monstrante variabili p demonstratum ut haec spatii pars ab aliis variabilibus adhiberi possit.

p reditus est valor ab ultima vocatione ad functiones mallocas et calloc;

valorem reddere:

nulli;

Nota: Declarationes supra quatuor functiones omnes in stdlib.h header file.

inane genus monstratorem:

Valores reditus praedictarum functionum malloc functionis et calloc functionis tam vacui sunt * typus, quod significat non demonstrat ad quamlibet speciem datae vel non indicat notitias cuiusdam generis.

Cum memoriam dynamicam vocant, programma tantum utitur pura inscriptione retractata ab officio, nec attributo utitur ad quod genus notitiae demonstrandum est.

Exempli gratia:

int * p *

p=(int*) malloc(100);

Causa:

Datam dynamicam creare, inputare pereuntis 5 studiosorum, et functione utere ad reprimendam num aliqui discipuli cum minore quam 60 puncta sint, et ustulo simpliciter outputo;

  1. #define _CRT_SECURE_NO_WARNINGS
  2. #include <stdio.h>
  3. #include <stdlib.h>
  4.  
  5. int main()
  6. {
  7. 	void check(int * p);
  8. 	int *p1, i;
  9. 	p1 = (int *)malloc(5 * sizeof(int));
  10. 	for (i = 0; i < 5; i++)
  11. 	{
  12. 		scanf("%d", p1 + i);
  13. 	}
  14. 	check(p1);
  15. 	return 0;
  16. }
  17. void check(int * p)
  18. {
  19. 	int i;
  20. 	printf("they are fail:n");
  21. 	for (i = 0; i < 5; i++)
  22. 	{
  23. 		if (*(p+i) < 60)
  24. 			printf("%d  ", *(p + i));
  25. 	}
  26. }

operatio effectus;

Proventus analysis:

Nulla ordinata in programmatis definita est, sed dynamica regio libera destinatio aperitur ad usum ordinata.

In munere mallo, nulla valoris specificus directe ad spatium dynamicum collocandi adhibetur. Utere p demonstrare ad primam orationem byte et illud int genus converte, et p+1 proximum elementum demonstrat.

4.3.2 De creatione dynamici coniunctorum list

Scribere munus ut album coniunctum dynamicum cum notitia pro 4 alumnis creare possit.

  1. #define _CRT_SECURE_NO_WARNINGS
  2. #include <stdio.h>
  3. #include <stdlib.h>
  4.  
  5. #define LEN sizeof(struct Student)
  6.  
  7. struct Student
  8. {
  9. 	long num;
  10. 	float score;
  11. 	struct Student * next;
  12. };
  13.  
  14. int n;
  15. struct Student * creat(void)
  16. {
  17. 	struct Student * head, *p1, *p2;
  18. 	n = 0; p1 = p2 = malloc(LEN);
  19. 	scanf("%ld%f", &p1->num, &p1->score);
  20. 	head = NULL;
  21. 	while (p1->num != 0)
  22. 	{
  23. 		n = n + 1;
  24. 		if (n == 1)
  25. 			head = p1;
  26. 		else  p2->next = p1;
  27. 		p2 = p1;
  28. 		p1 = (struct Student *)malloc(LEN);
  29. 		scanf("%ld%f", &p1->num, &p1->score);
  30. 	}
  31. 	p2->next = NULL;
  32. 	return (head);
  33. 	}
  34.  
  35. int main()
  36. {
  37. 	struct Student * pt;
  38. 	pt = creat();
  39. 	printf("n num:%ld score:%5.2fn", pt->num, pt->score);
  40. 	return 0;
  41. }
  42.  
  43.

operatio effectus;

Proventus analysis: Ad album dynamicum connexum creare, primum tres indicis structurae specificatae sunt, ac deinde munus mallocum nodi creare adhibetur. Omnes tres indicis compages huic nodi demonstrant, et p1 utitur munere mallocti ad nodi creandum et p2 Next . Nodi creato demonstrat. Post p2=p1 demonstrato, p1 creat p2. Nodus nodi nuper creatus. NULL.

Input and output of dynamica coniunctione list:

  1. #define _CRT_SECURE_NO_WARNINGS
  2. #include <stdio.h>
  3. #include <stdlib.h>
  4.  
  5. #define LEN sizeof(struct Student)
  6.  
  7. struct Student
  8. {
  9. 	long num;
  10. 	float score;
  11. 	struct Student * next;
  12. };
  13. int n;
  14. struct Student * creat(void)
  15. {
  16. 	struct Student * head, *p1, *p2;
  17. 	head = NULL;
  18. 	n = 0;
  19. 	p2 = p1 = malloc(LEN);
  20. 	scanf("%ld%f", &p1->num, &p1->score);
  21. 	while (p1->num != 0)
  22. 	{
  23. 		n = n + 1;
  24. 		if (n == 1)
  25. 			head = p1;
  26. 		else
  27. 			p2->next = p1;
  28. 		p2 = p1;
  29. 		p1 = malloc(LEN);
  30. 		scanf("%ld %f", &p1->num, &p1->score);
  31. 	}
  32. 	p2->next = NULL;
  33. 	return head;
  34. }
  35.  
  36. void print(struct Student * p)
  37. {
  38. 	do
  39. 	{
  40. 		printf("%ld %5.2fn", p->num ,p->score);
  41. 		p=p->next;
  42. 	} while (p->num != NULL);
  43. }
  44.  
  45. int main(void)
  46. {
  47. 	struct Student * pt;
  48. 	pt = creat();
  49. 	print(pt);
  50. 	return 0;
  51. }

operatio effectus;

5. Unionis genus

5.1 Overview

Aliquando, vis variarum variabilium in memoria unitatis condere. Exempli gratia, variabiles integros pone, variabiles mores, et punctum variabile fluitans in memoria unitatis ab eadem inscriptione incipiens Sectio structurae memoriae "unio" appellatur.

Definire formam communem unionis;

unio unio nomen

        {

membrum album;

}Variable list;

Exempli gratia:

unio Data

        {

int i;

char ch;

natare f;

}a,b,c;

Memoria longitudo quam structura variabili occupata est summa memoria longitudinum ab unoquoque membro occupata;

5.2 Quotes

Unio variabiles tantum, quae ante definitae sunt, referri possunt. Nota nos non variabiles unionis referentes, sed variabiles unionis referenced membra.

ai refert integer variabilis in unione variabilis;

a.ch refertur ad indolem variabilem in unione variabili;

af refertur ad realem variabilem in unione variabili;

5.3 Features

1. Segmentum memoriae uti potest plura genera membrorum condere, sed una tantum singulis momentis potius quam plures simul condi possunt.

2. Unio variabiles initialized fieri possunt, sed una tantum in mensa initializatione constans esse potest.

3. Sodalis unionis variabilis est membrum ultimo tempore assignatum et prior originalis variabilis overscribitur et reponitur.

4. Oratio variabilis unionis eadem est ac oratio membrorum.

5. Valorem unionis nominis variabilis assignare non potes nec nomen variabile ad valorem referendum conaris.

6. Enumeratio generis

Si variabiles aliquae tantum valores possibiles habent, definiri possunt rationes enumerationis; enumeratio sic dicta est quod valores possibilis singillatim recensebunt.

Enumeratio generis incipit cum enum;

eunm Preces{sol,mon,tue,hue,fri,sat};

Genus enum Preces Enumeratio supra declarat. Hoc genus tunc adhiberi potest ad variabiles differentias definiendas.

enum Preces profesto, volutpat;

Inter eas, profesto et volutpat definiuntur variabilium enumeratio, et unci crispi enumerationem elementorum vel enumerationem constantium dicuntur.

Forma generalis declarandi generis enumerationem:

enum [enumeratio name] {elementum enumerationis};

Exemplum:

Sunt 5 globuli genera in sinu: rubei, flavi, caerulei, albi et nigri.

  1. #define _CRT_SECURE_NO_WARNINGS
  2. #include <stdio.h>
  3.  
  4. int main()
  5. {
  6. 	enum Color {red,yellow,bule,white,black};
  7. 	enum Color i, j, k, pri;
  8. 	int n, loop;
  9. 	n = 0;
  10. 	for (i = red; i <= black; i++)
  11. 		for (j = red; j <= black; j++)
  12. 			if (i != j)
  13. 			{
  14. 		for (k = red; k <= black; k++)
  15.  
  16. 			if ((k != i) && (k != j))
  17. 			{
  18. 			n++;
  19. 			printf("%d ", n);
  20. 			for (loop = 1; loop <= 3; loop++)
  21. 			{
  22. 				switch (loop)
  23. 				{
  24. 				case 1:pri = i; break;
  25. 				case 2:pri = j; break;
  26. 				case 3:pri = k; break;
  27. 				default:break;
  28. 				}
  29.  
  30. 				switch (pri)
  31. 				{
  32. 				case red:printf("%s ", "red"); break;
  33. 				case yellow:printf("%s ", "yellow"); break;
  34. 				case bule:printf("%s ", "bule"); break;
  35. 				case white:printf("%s ", "white"); break;
  36. 				case black:printf("%s ", "black"); break;
  37. 				default:break;
  38. 				}
  39. 			}
  40. 			printf("n");
  41. 				}
  42. 			}
  43. 	printf("n total:%dn", n);
  44. 	return 0;
  45. }

operatio effectus;

7. Usus typedef indicare novum genus nominis

Utere typedef ad specificare novum genus nominis, ut exstantis generis nomen reponat;

1. Simpliciter repone primi generis nomen cum novo generis nomine.

Exempli gratia:

typedef int Integer;

typedef float Real;

Ita duae sequentes lineae aequiparantur;

int i，j ---- Integer i,j;

2. Nomen simplex genus nominis loco complexi generis representation modum

  Nomen novi generis nomen est ut structurae genus;

typedef instruere

        {

int mun;

                ......

} Data;

Nomen novi generis tum Data ad variabilem definiendam;

Data dies natalis;

Data * p;

      Nomen novum genus nominis loco ordinata type:

typedef int Num[100];

Num a;

      Nomen novum genus nomen ad significandum monstratorem genus：

typedef char * String;

String p,a[10];

      Nomen novum genus nominis ad monstratorem functionis repraesentandum;

typedef int (* Indicium)();

Indicium p1,p2;

           Summarium: Iuxta modum variabilium definiendi, substitue nomen variabile cum nomine novo speciei, et adde typedef in fronte ad declarandum novum genus nomen figuram originalem repraesentare.

typetef solum significat novum genus nominis generis existentis, sed novum genus non creat.

typetef and #define have superficial similarities.

typedef int comitis

#define comitis int

Eorum munus est uti comite loco int, sed re vera differunt. #definire discursum est in prae-compilatione, adhiberi potest tantum ut simplex chorda subrogandi, dum typedef in scaena compilatione processit. Non est repositum simplex. Sed novum genus nomen generatur et variabile definitur.

Personal profile

technologiae technologiae plus quam 30 annos operam dedit et in variis linguis proficit ut java, linux, javascript, php, css, etc. Multas contributiones in aperto fonte campo fecit elit documentorum statione ad communicandas quaestiones in technologia progressus ad futuram referentiam

mihi contactus notitia

Mail