复合类型（自定义类型）

最新推荐文章于 2024-05-30 11:27:58 发布
最新推荐文章于 2024-05-30 11:27:58 发布
阅读量345 收藏 10
点赞数 10
分类专栏： C 文章标签： 开发语言 c语言 笔记
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_38342510/article/details/135258019
版权

1、结构体

1.1、概述
  • 将不同类型的数据组合成一个有机的整体。
1.2、结构体变量的定义和初始化

1）结构体变量的定义

  • 先声明结构体类型再定义变量名
  • 在声明类型的同时定义变量
  • 直接定义结构体类型变量（无类型名）

2）结构体类型和结构体变量的关系

  • 结构体类型：相当于一个模型，但其中并无具体数据，系统对之也不分配实际内存单元
  • 结构体变量：系统根据结构体类型（内部成员状况）为之分配空间

3）结构体的定义格式：

struct 结构体名
{
	成员列表
}
1.3、结构体成员的使用
//结构体定义
struct student
{
    char name[21];
    int age;
    int score;
    char addr[51];
}stu1,stu2,stu3;		//在定义结构体的时候可以直接进行变量创建和赋值

int main()
{
    //创建结构体变量
    //结构体类型 结构体变量名
     /*
    struct student stu;
    
   
    //stu.name="张三";	err，字符数组不能被赋值
    strcpy(sstu.name,"张三");
    stu.age=18;
    stu.score=100;
    //stu.addr="北京市朝阳区";
    strcpy(stu.addr,"北京市朝阳区");
    */
    
    //另一种快速赋值的方式
    struct student stu=("张三",18,100,"北京市朝阳区");
    
    printf("姓名：%s\n",stu.name);
    printf("年龄：%d\n",stu.age);
    printf("成绩：%d\n",stu.score);
    printf("地址：%s\n",stu.addr);
    
    
    return 0;
}

1）从键盘输入初始化结构体

//结构体定义
struct student
{
    char name[21];
    int age;
    int score;
    char addr[51];
};

int main()
{
    struct student stu;
    scanf("%s%d%d%s",stu.name,&stu.age,&stu.score,stu.addr);
    printf("姓名：%s\n",stu.name);
    printf("年龄：%d\n",stu.age);
    printf("成绩：%d\n",stu.score);
    printf("地址：%s\n",stu.addr);
    
    return 0;
}
1.4、结构体数组
//结构体定义
struct student
{
    char name[21];
    int age;
    char sex;
    int score[3];
    char addr[51];
};

int main()
{
    struct student stu[3]=
    {
        {"张三",22,'M',88,99,10,"河北唐山"},
        {"李四",23,'F',59,59,59."河北邯郸"},		//也可以这样：{.addr="河北邯郸","李四",23,'F',59,59,59},
        {"王五",18,'M',100,100,100,"黑龙江大庆"}
    };
    //结构体数组元素个数计算
    printf("结构体数组大小：%d\n",sizeof(stu));						//288
    printf("结构体数组元素大小：%d\n",sizeof(stu[0]));				//96
    printf("结构体数组大小：%d\n",sizeof(stu)/sizeof(stu[0]));			//3
    
    for(int i=0;i<3;i++)
    {
        printf("姓名：%s\n",stu[i].name);
        printf("年龄：%d\n",stu[i].age);
        printf("性别：%s\n",stu[i].sex='M'?"男":"女");
        printf("成绩1：%d\n",stu[i].score[0]);
        printf("成绩2：%d\n",stu[i].score[1]);
        printf("成绩3：%d\n",stu[i].score[2]);
        printf("地址：%s\n",stu[i].addr);
    }
    return 0;
}

1）结构体元素个数计算

//结构体数组元素个数计算
    printf("结构体数组大小：%d\n",sizeof(stu));						//288
    printf("结构体数组元素大小：%d\n",sizeof(stu[0]));				//96
    printf("结构体数组大小：%d\n",sizeof(stu)/sizeof(stu[0]));			//3

2）结构体成员需要偏移对齐

  • 上面的结构体数组元素大小原本是：21+4+1+3*4+51=89字节，实际输出是 96字节。
  • 结构体需要偏移对齐，以最大的数据类型为基准。
1.5、结构体数组排序
int main()
{
	struct student stu[3]=
    {
        {"张三",22,'M',88,99,10,"河北唐山"},
        {"李四",23,'F',59,59,59."河北邯郸"},		
        {"王五",18,'M',100,100,100,"黑龙江大庆"}
    };
    
    //按照年龄排序
    for(int i=0;i<3-1;i++)
    {
        for(int j=0;j<3-1-i;j++)
        {
            if(stu[j].age>stu[j+1].age)
            {
                struct student temp=stu[j];
                stu[j]=stu[j+1];
                stu[j+1]=temp;
            }
        }
    }
    for(int i=0;i<3;i++)
    {
        printf("姓名：%s\n",stu[i].name);
        printf("年龄：%d\n",stu[i].age);
        printf("性别：%s\n",stu[i].sex='M'?"男":"女");
        printf("成绩1：%d\n",stu[i].score[0]);
        printf("成绩2：%d\n",stu[i].score[1]);
        printf("成绩3：%d\n",stu[i].score[2]);
        printf("地址：%s\n",stu[i].addr);
    }
    return 0;
}
1.6、开辟堆空间存储结构体
typedef struct student ss;

struct student
{
    char name[21];
    int age;
    char sex;
    int score[3];
    char addr[51];
};

int main()
{
    //printf("%d\n",sizeof(struct student));		//96
    //开辟堆区存储结构体数组
    //struct student* p=(struct student*)macllo(sizeof(struct student));
    ss* p=(ss*)macllo(sizeof(ss)*3);
    printf("结构体指针的大小：%d\n",sizeof(p));		//32位系统输出4,64位系统输出8
    
    //赋值
    for(int i=0;i<3;i++)
    {
        scanf("%s%d%,c%d%d%d%s",p[i].name,&p[i].age,&p[i].sex,		//这里加逗号是为了防止输入时候用于分隔的空格被读入
              &p[1].score[0],&p[1].score[1],&p[1].score[2],p[i].addr);
    }
    
    for(int i=0;i<3;i++)
    {
        printf("姓名：%s\n",p[i].name);
        printf("年龄：%d\n",p[i].age);
        printf("性别：%s\n",p[i].sex='M'?"男":"女");
        printf("成绩1：%d\n",p[i].score[0]);
        printf("成绩2：%d\n",p[i].score[1]);
        printf("成绩3：%d\n",p[i].score[2]);
        printf("地址：%s\n",p[i].addr);
    }
    //释放空间
    free(p);
    return 0;
}
1.7、结构体嵌套结构体
/*
struct 技能
{
	名称
	等级
	伤害
	范围
	耗蓝
	冷却
};

struct 人物信息
{
	等级
	经验
	金钱
	hp
	mp
	力量
	智力
	敏捷
	struct 技能 skills[4]
};

struct 人物信息 info;
info.skills[0].名称;
*/

struct scores
{
    int c;
    int cpp;
    int cs;
};

struct student
{
    char name[21];
    int age;
    struct scores ss;
    char addr[51];
};

int main()
{
    struct student stu={"貂蝉",18,99,99,99,"徐州"};
    printf("%s\n%d\n%d\n%d\n%d\n%s\n",stu.name,stu.age,stu.ss.c,stu.ss.cpp,stu.ss.cs,stu.a);
    
    printf("成绩结构体大小：%d\n",sizeof(struct scores));		//92
    printf("学生结构体大小：%d\n",sizeof(struct student));		//92
    return 0;
}
1.8、结构体赋值
  • 结构体赋值，会产生一个独立的变量（结构体成员为非指针的情况下）
struct student
{
    char name[21];
    int age;
    int score;
    char addr[51];
};

int main()
{
    struct student stu={"孙尚香",26,60,"巴蜀"};
    struct student s1=stu;		//结构体赋值，会产生一个独立的变量
    strcpt(s1.name,"甘夫人");
    
    printf("%s\n",stu.name);	//孙尚香	这里s1和stu是两个独立的内存空间
}
1.9、结构体和指针

1）指向普通结构体变量的指针

  • 开辟堆空间存储结构体

2）结构体成员为指针类型

struct student
{
    char* name;
    int age;
    int* scores;
    char* addr;
};

int main()
{
    struct student stu;
    //stu.name="张三";	如此赋值没错，但是name指向一个字符串常量，不可修改
    stu.name=(char*)malloc(sizeof(char)*21);
    strcpy(stu.name,"张三")；
    stu.scores=(int*)malloc(sizeof(int)*3);
    stu.addr=(char*)malloc(sizeof(char)*51);
    str.age=18;
    stu.scores[0]=88;
    stu.scores[1]=77;
    stu.scores[2]=99;
    strcpy(stu.addr,"北京市昌平区");
    
    free(stu.name);
    free(stu.scores);
    free(stu.addr);
    return 0;
}

3）结构体指针：指向结构体的指针

  • 通过指针访问结构体成员，利用指针的取值运算
//通过指针访问结构体成员，利用指针的取值运算
//结构体变量.成员
printf("%s\n",(*p).name);
printf("%d\n",(*p).age);
  • 过指针访问结构体成员，利用指针的指向运算符
//通过指针访问结构体成员，利用指针的指向运算符
//结构体指针->成员
printf("%s\n",p->name);
printf("%d\n",p->age);
    

struct student
{
    char name[21];
    int age;
    int scores;
    char addr[51];
};

int main()
{
    struct student stu={"林冲",30,100,100,100,"汴京"};
    struct student* p;
    p=&stu;
    
    //通过指针访问结构体成员，利用指针的取值运算
    printf("%s\n",(*p).name);
    printf("%d\n",(*p).age);
    
    //通过指针访问结构体成员，利用指针的指向运算符
    printf("%s\n",p->name);
    printf("%d\n",p->age);
    
    return 0;
}

typedef struct student ss;
struct student
{
	char* name;
    int age;
    int* scores;
    char* addr;
};

int main()
{
    ss* p=(ss*)malloc(sizeof(ss)*3);
    
    //开辟堆空间
    for(int i=0;i<3;i++)
    {
        (p+i)->name=(char*)malloc(sizeof(char)*21);
        p[i].scores=(int*)malloc(sizeof(int)*3);
        p[i].addr=(char*)malloc(sizeof(char)*51);
    }
    
    //输入
    for(int i=0;i<3;i++)
    {
        scanf("%s%d%d%d%d%s",(p+i)->name,&p[i].age,&p[i].scores[0],
              p[i].scores[1],&p[i].scores[2],p[i].addr);
    }
    
    //输出
    for(int i=0;i<3;i++)
    {
        printf();
    }
    
    //释放堆空间
    for(int i=0;i<3;i++)
    {
        free(p[i].name);
        free((p+i)->scores);
        free(p[i].addr);
    }
    free(p);
}
1.10、结构体做函数参数

1）结构体普通变量做函数参数：值传递

/*
typedef struct student ss;
struct student
{
    char name[21];
    int age;
    int score;
    char addr[51];
};

void func(ss stu)	//值传递
{
    strcpy(stu.name,"卢俊义");
    printf("%s\n",ss.name);		//卢俊义
}
int main()
{
    ss stu={"宋江",50,101,"水泊梁山"};
    func(stu);		//值传递
    printf("%s\n",stu.name);	//宋江
    
    return 0;
}
*/
typedef struct student ss;
struct student
{
    char* name;
    int age;
    int score;
    char addr[51];
};

void func(ss stu)	//值传递
{
    strcpy(stu.name,"卢俊义");
    printf("%s\n",ss.name);		//卢俊义
}

void func1(ss stu)	//值传递
{
    stu.name=(char*)malloc(sizeof(char)*21);
    strcpy(stu.name,"卢俊义");
    printf("%s\n",ss.name);		//卢俊义
}
int main()
{
    ss stu={NULL,50,101,"水泊梁山"};
    stu.name=(char*)malloc(sizeof(char)*21);
    strcpy(stu.name,"宋江");
    func1(stu);		//值传递
    printf("%s\n",stu.name);	//宋江
    
    func(stu);		//值传递
    printf("%s\n",stu.name);	//卢俊义
    
    return 0;
}

2）结构体指针变量做函数参数：地址传递

typedef struct student ss;
struct student
{
    char name[21];
    int age;
    int score;
    char addr[51];
};

void func(ss* p)	//地址传递
{
    strcpy(p->name,"公孙胜");
    printf("%s\n",p->name);		//公孙胜
}
int main()
{
    ss stu={"吴用",50,101,"水泊梁山"};
    func(&stu);		//地址传递
    printf("%s\n",stu.name);	//公孙胜
    
    return 0;
}

3）结构体数组做函数参数：退化为指针，地址传递

typedef struct student ss;
struct student
{
    char name[21];
    int age;
    int score;
    char addr[51];
};

//数组作为函数参数，退化为指针，需要传递元素个数
void BubbleSort(ss* stu,int length)	//地址传递
{
    printf("%d\n",sizeof(stu));
    for(int i=0;i<3-1;i++)
    {
        for(int j=0;j<3-i-1;j++)
        {
            if(stu[j].age>stu[j+1].age)
            {
                ss temp=stu[j];
                stu[j]=stu[j+1];
                stu[j+1]=temp;
            }
        }
    }
}

int main()
{
    ss stu[3]=
    {
        {"鲁智深",30,33,"五台山"},
        {"呼延灼",45,44,"汴京"},
        {"顾大嫂",28,55,"汴京"}
    };
    BubbleSort(stu,3);		//输出：4	即指针的大小
    
    
    return 0;
}

4）const 修饰结构体指针形参变量

  • 与 const 修饰其他变量形参是一致的
  • const 修饰结构体指针类型
typedef struct student ss;
struct student
{
    char name[21];
    int age;
    int scores[3];
    char addr[51];
};

int main()
{
    ss stu1={"孙悟空",700,101,101,101,"花果山"};
    ss stu2={"猪八戒",1200,1001,1001,1001,"高老庄"};
    const ss* p=&stu1;		//const 修饰结构体指针类型
    p=&stu2;	//OK
    p->age=888;		//err
    (*p).age=888;	//err
    return 0;
}
  • const 修饰结构体指针变量
typedef struct student ss;
struct student
{
    char name[21];
    int age;
    int scores[3];
    char addr[51];
};

int main()
{
    ss stu1={"孙悟空",700,101,101,101,"花果山"};
    ss stu2={"猪八戒",1200,1001,1001,1001,"高老庄"};
    ss* const p=&stu1;		//const 修饰结构体指针变量
    p=&stu2;	//err
    p->age=888;		//OK
    (*p).age=888;	//OK
    strcpy(p->name,"沙悟净");		//OK
    return 0;
}
  • const 修饰结构体指针变量和指针类型
typedef struct student ss;
struct student
{
    char name[21];
    int age;
    int scores[3];
    char addr[51];
};

int main()
{
    ss stu1={"孙悟空",700,101,101,101,"花果山"};
    ss stu2={"猪八戒",1200,1001,1001,1001,"高老庄"};
    const ss* const p=&stu1;		//const 修饰结构体指针变量和指针类型
    p=&stu2;	//err
    p->age=888;		//err
    (*p).age=888;	//err
    strcpy(p->name,"沙悟净");		//err
    
    ss** pp=&p;
    (*pp)->age=1234;	//OK
    *pp=&stu2;			//OK
    
    **PP.age=789;		//OK
    
    return 0;
}

2、共用体（联合体）

  • 联合体 union 还一个能在同一个存储空间存储不同类型数据的类型；
  • 联合体所占的内存长度等于其最长成员的长度倍数；
  • 同一内存段可以用来存放几种不同类型的成员，但是每一瞬时只有一种起作用；
  • 共用体变量中起作用的成员是最后一次存放的成员，在存入一个新的成员后原有的成员的值会被覆盖；
  • 共用体变量的地址和它的各成员的地址都是同一地址。
union Var
{
    int a;
    float b;
    double c;
    char d;
    short f;
    //short f[6];	//如果这样，那么sizeof(Var)=16
    //内存对齐，最大类型的整数倍对齐
};

int main()
{
    union Var uVar;
    /*
    uVar.a=100;
    printf("%d\n",uVar.a);		//100
    */
    
    uVar.a=100;
    uVar.b=3.14;
    printf("%d\n",uVar.a);		//乱码
    printf("%f\n",uVar.b);		//3.14
    
    printf("%d\n",sizeof(uVar));		//8	大小和最大的类型有关
    
    printf("%p\n",&uVar);
    printf("%p\n",&uVar.a);
    printf("%p\n",&uVar.b);
    printf("%p\n",&uVar.c);
    printf("%p\n",&uVar.d);
    printf("%p\n",&uVar.e);
    printf("%p\n",&uVar.f);		//输出的地址相同
    
    return 0;
}

3、枚举

  • 枚举：将变量值一一列举出来，变量的值只限于列举出来的值的范围内。
3.1、枚举的定义：
enum 枚举名
{
    枚举值表
}
  • 在枚举值表中应列出所有可用值，也称为枚举元素
  • 枚举值是常量，不能在程序中用赋值语句再对它赋值
  • 枚举元素本身由系统定义了一个表示序号的数值从 0 开始顺序定义为：0、1、2、……
enum color
{
    red,blue,green,pink,yellow,black,white
};

//也可以你使用系统默认的值，自定义赋值
enum color1
{
    red=10,blue,green,pink,yellow=20,black,white
};

int main()
{
    int value;
    scanf("%d",&value);
    enum color colorName;
    switch(value)
    {
    case red:
        printf("红色\n");
    	break;
    case blue:
        printf("蓝色\n");
    	break;
    case green:
        printf("绿色\n");
    	break;
    case pink:
        printf("粉色\n");
    	break;
    case yellow:
        printf("黄色\n");
    	break;
    case black:
        printf("黑色\n");
    	break;
    case white:
        printf("白色\n");
    	break;
    default:
        break;
    }
    return 0;
}
3.2、枚举流程控制案例
enum TYPE
{
    run,attack,skill,dance=10,showUI,frozen=20,dizzyn,dath,moti=30
    //值分别为：0、1、2、10、11、20、21、22、30
}type;

int main()
{
    int value;
    while(1)
    {
        scanf("%d",&value);
        switch(type)
    	{
        	case run:
                printf("正在移动中……\n");
                //value=30;
           	 	break;
        	case attack:
                printf("正在攻击中……\n");
            	break;
        	case skill:
                printf("正在施法中……\n");
            	break;
        	case dance:
                printf("正在跳舞中……\n");
            	break;
        	case showUI:
                printf("正在显示徽章中……\n");
            	break;
        	case frozen:
                printf("正在被冰冻中……\n");
            	break;
        	case dizzyn:
                printf("正在被眩晕中……\n");
            	break;
        	case dath:
                printf("死亡……\n");
                return 0;
            	break;
        	case moti:
                printf("等待释放命令中……\n");
            	break;
        	default:
            	break;
    	}
    }
    
    return 0;
}

4、typedefine

  • 为一种数据类型（基本类型或自定义类型）定义一个新名字，不能创建新类型
  • 与 #define 不同，typedef 仅限于数据类型，不能是表达式或者具体的值
  • #define 发生在预处理，typedef 发生在编译阶段

1）为已经存在的数据类型取别名

typedef unsigned int ui;
typedef struct student
{
    char name[21];
    int age;
    int score;
    char addr[51];
}ss;

int main()
{
    ui a=10;
    ss stu;
    return 0;
}

2）定义函数指针

哦豁灬
关注
  • 10
    点赞
  • 踩
  • 10
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
oracle自定义的记录类型,oracle 自定义类型 type / create type
weixin_35667833的博客
04-02 1442
一：Oracle中的类型有很多种，主要可以分为以下几类：1、字符串类型。如：char、nchar、varchar2、nvarchar2。2、数值类型。如：int、number(p,s)、integer、smallint。3、日期类型。如：date、interval、timestamp。4、PL/SQL类型。如：pls_integer、binary_integer、binary_double(10g...
ORACLE 自定义类型 type/ object
热门推荐
tan1012194073的博客
03-28 1万+
一：Oracle中的类型有很多种，主要可以分为以下几类： 1、字符串类型。如：char、nchar、varchar2、nvarchar2。 2、数值类型。如：int、number(p,s)、integer、smallint。 3、日期类型。如：date、interval、timestamp。 4、PL/SQL类型。如：pls_integer、binary_in
Java复合数据类型
theVicTory的博客
02-01 5476
1、Java字符串 在 Java 中字符串被作为 String 类型的对象处理。String 类位于 java.lang 包中，默认情况下该包自动导入。 String对象创建后不会被修改，当我们修改某个字符串对象实际上是将原引用指向了新创建的内存空间。并且相同的字符串常量Java不会分配两个内存空间，而是将两个引用指向相同的空间。 public class MyString { ...
C++：基本内置类型和复合类型
江南好
01-20 2967
前言 数据类型是程序的基础，其说明了数据的意义，以及在数据上所能执行的操作。 C++语言支持广泛的数据类型，其定义了基本内置类型，和提供了自定义数据类型的机制。基于基本内置类型和自定义数据类型的机制，C++标准库定义了一些更加复杂的数据类型，如可变长字符串和向量等，同样，程序员本人也可以基于此定义一些自己需要的数据类型。 基本内置类型 C++定义的一组内置数据类型包括：算术类型（Arithmeti...
复合数据类型
csdn_lfy的博客
03-14 4284
复合数据类型 一、数据类型可分为两大类： 1.内置类型： (1).基本类型：整形（int，char，Boolean），浮点型（double，float），void （2）复合类型：数组，结构体，指针，引用，枚举，共同体 2.自定义类型： （1）用户自定义类 （2）标准库中定义的类型（STL标准模板库） 二、结构体 （ 数组只能储存同种类型的数据。） 结构体：由一系列具有相同类型或不同类型的数据...
postgresql 复合数据类型的使用方法
u013992330的博客
11-28 2766
postgresq 数据库的数据类型分为4种：基本数据类型、复合数据类型、域以及伪类型 基本类型：数据库内置数据类型，例如integer、char、varchar等 复合数据类型：需要用户自定义，所谓复合就是把多个基本类型融合在一起使用，复合类型的字段实际上就是一个特殊的数组 域：一种特殊的基本数据类型，由基本数据类型加上约束条件构成 伪类型：“伪”说明它不是真正的数据类型，这些数据类型不
Numpy：自定义复合数据类型
weixin_30398227的博客
01-23 425
Numpy的自定义复合数据类型 ''' numpy自定义复合类型 在ndarray数组中存储3位学生信息（三个字段：姓名、成绩、年龄） ''' import numpy as np data = [('zs', [10, 15, 2], 3), ('ls', [12, 12, 92], 8), ('ww', [14, 35, 82]...
oracle 自定义类型 type / create or replace type
qq_35306939的博客
11-26 2715
一：Oracle中的类型有很多种，主要可以分为以下几类： 1、字符串类型。如：char、nchar、varchar2、nvarchar2。 2、数值类型。如：int、number(p,s)、integer、smallint。 3、日期类型。如：date、interval、timestamp。 4、PL/SQL类型。如：pls_integer、binary_integer、binary_double...
oracle 赋值表数据类型,ORACLE 自定义类型 type/ object
weixin_42488997的博客
04-05 2033
一：Oracle中的类型有很多种，主要可以分为以下几类：1、字符串类型。如：char、nchar、varchar2、nvarchar2。2、数值类型。如：int、number(p,s)、integer、smallint。3、日期类型。如：date、interval、timestamp。4、PL/SQL类型。如：pls_integer、binary_integer、binary_double(10g...
JavaScript复合类型
游海东的技术专栏
08-11 1910
1、Object：对象 2、Array：数组 3、Function：函数
SQL语句 第11章 复合数据类型
03-12
SQL语句 第11章 复合数据类型 使用显式方法定义记录 在DML语句中使用记录
rule-engine:一种轻量级，可选类型的表达语言，具有用于匹配任意Python对象的自定义语法
05-13
复合数据类型（等同于Python dict，列表和集合类型） 资料属性 线程安全 用法示例 以下示例演示了定义规则对象并将其应用于两个字典的基本用法，显示了一个匹配而另一个不匹配。 有关更多信息，请参见。 import ...
WinRTXamlToolkit.Controls.DataVisualization.Charting图形报表下自定义控件
02-19
WinRTXamlToolkit.Controls.DataVisualization.Charting图形报表下自定义控件，分为单组数据图形使用SingleChart用户控件和多组数据图形使用MixedChart用户控件。传递数据集合和其它参数，让图形按需展示。 一、...
超强自定义问卷调查系统 v2019
10-22
可自定义题目类型（如单选，多选，复合选，复合填空，等等，只要是表单上有的都可以组合生成，超强自定义）可自由更换界面，使用时提交和提交成功界面均是纯Html格式，调查组织方随意编辑。随时可对使用中投票调查...
基于UG回转零件车/铣复合数控加工
07-01
以回转零件车/铣复合数控加工为目标,结合企业生产实际,采用UG加工模块的车削、铣削、钻削加工类型,采用优化的数控加工工艺对零件进行数控编程,并采用自定义的后处理文件生成了相应数控系统的数控代码。实验结果表明...
聊一聊开发语言的基础控制结构
m0_46552684的博客
05-28 1176
一、描述下for循环、while循环和do-while循环的区别和用法。在编程中，for循环、while循环和do-while循环是用于重复执行一段代码直到满足特定条件的控制结构。每种循环都有其特定的用途和语法。
C语言笔记第9篇：字符函数和字符串函数
2302_78977491的博客
05-28 935
在编程的过程中，我们经常要处理字符和字符串，为了方便操作字符和字符串，C语言标准库中提供了一系列库函数，接下来我们就学习一下这些函数。一、
Linux学习笔记（二）
weixin_42515203的博客
05-28 334
Linux的学习笔记
Vue3实战笔记（52）—Vue 3封装持仓分析饼图
最新发布
山花的博客
05-30 494
接上文，封装持仓分析饼图。封装好几个组件，用于后续开发。把忧愁煮成茶，让它在心间慢慢沉淀，剩下的，便是清甜的回味。
MPI自定义数据类型
05-18
MPI自定义数据类型可以分为两类：基本类型和复合类型。基本类型包括MPI_INT、MPI_FLOAT等标准的MPI数据类型，而复合类型则由多个基本类型组成，例如结构体或数组。用户可以使用MPI_Type_create_struct、MPI_Type_...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值