x264_param_t 结构体参数说明
x264_param_t 结构体参数说明
ty pedef struct x264_param_t
{
/* CPU 标志位*/
unsigned int cpu;
int i_threads; /* 并行编码多帧*/
int b_deterministic; /*是否允许非确定性时线程优化*/
int i_sy nc_lookahead; /* 线程超前缓冲*/
/* 视频属性*/
int i_width; /* 宽度*/
int i_height; /* 高度*/
int i_csp; /* 编码比特流的CSP,仅支持i420，色彩空间设置*/
int i_lev el_idc; /* lev el值的设置*/
int i_f rame_total; /* 编码帧的总数, 默认0 */
/*Vui参数集视频可用性信息视频标准化选项*/
struct
{
/* they will be reduced to be 0 < x <= 65535 and prime */
int i_sar_height;
int i_sar_width; /* 设置长宽比*/
int i_ov erscan; /* 0=undef, 1=no ov erscan, 2=ov erscan 过扫描线，默认"undef"(不设置)，可选项：show(观看)/crop(去除)*/
/*见以下的值h264附件E */
Int i_v idf ormat;/* 视频格式，默认"undef"，component/pal/ntsc/secam/mac/undef*/
int b_f ullrange; /*Specify full range samples setting，默认"off"，可选项：off/on*/
int i_colorprim; /*原始色度格式，默认"undef"，可选项：undef/bt709/bt470m/bt470bg，smpte170m/smpte240m/f ilm*/ int i_transf er; /*转换方式，默认"undef"，可选项：undef/bt709/bt470m/bt470bg/linear,log100/log316/smpte170m/smpte240m*/ int i_colmatrix; /*色度矩阵设置，默认"undef",undef/bt709/f cc/bt470bg,smpte170m/smpte240m/GBR/YCgCo*/
int i_chroma_loc; /* both top & bottom色度样本指定，范围0~5，默认0 */
} v ui;
int i_f ps_num;
int i_f ps_den;
/*这两个参数是由f ps帧率确定的，赋值的过程见下：
{ f loat f ps;
if( sscanf( v alue, "%d/%d", &p->i_f ps_num, &p->i_f ps_den ) == 2 )
;
else if( sscanf( v alue, "%f", &f ps ) )
{
p->i_f ps_num = (int)(fps * 1000 + .5);
p->i_f ps_den = 1000;
}
else
b_error = 1;
}
Value的值就是f ps。*/
/*流参数*/
int i_f rame_ref erence; /* 参考帧最大数目*/
int i_key int_max; /* 在此间隔设置IDR关键帧*/
int i_key int_min; /* 场景切换少于次值编码位I, 而不是IDR. */
int i_scenecut_threshold; /*如何积极地插入额外的I帧*/
int i_bf rame; /*两个相关图像间P帧的数目*/
int i_bf rame_adaptiv e; /*自适应B帧判定*/
int i_bf rame_bias; /*控制插入B帧判定，范围-100~+100，越高越容易插入B帧，默认0*/
int b_bf rame_py ramid; /*允许部分B为参考帧*/
/*去块滤波器需要的参数*/
int b_deblocking_f ilter;
int i_deblocking_f ilter_alphac0; /* [-6, 6] -6 light filter, 6 strong */
int i_deblocking_f ilter_beta; /* [-6, 6] idem */
/*熵编码*/
int b_cabac;
int i_cabac_init_idc;
int b_interlaced; /* 隔行扫描*/
/*量化*/
int i_cqm_preset; /*自定义量化矩阵(CQM),初始化量化模式为f lat*/
char *psz_cqm_f ile; /* JM f ormat读取JM格式的外部量化矩阵文件，自动忽略其他—cqm 选项*/ uint8_t cqm_4iy[16]; /* used only if i_cqm_preset == X264_CQM_CUSTOM */
uint8_t cqm_4ic[16];
uint8_t cqm_4py[16];
uint8_t cqm_4pc[16];
uint8_t cqm_8iy[64];
uint8_t cqm_8py[64];
/* 日志*/
void (*pf_log)( v oid *, int i_lev el, const char *psz, v a_list );
void *p_log_priv ate;
int i_log_lev el;
int b_v isualize;
char *psz_dump_y uv; /* 重建帧的名字*/
/* 编码分析参数*/
struct
{
unsigned int intra; /* 帧间分区*/
unsigned int inter; /* 帧内分区*/
int b_transf orm_8x8; /* 帧间分区*/
int b_weighted_bipred; /*为b帧隐式加权*/
int i_direct_mv_pred; /*时间空间队运动预测*/
int i_chroma_qp_offset; /*色度量化步长偏移量*/
int i_me_method; /* 运动估计算法(X264_ME_*) */
int i_me_range; /* 整像素运动估计搜索范围(f rom predicted mv) */
int i_mv_range; /* 运动矢量最大长度(in pixels). -1 = auto, based on lev el */
int i_mv_range_thread; /* 线程之间的最小空间. -1 = auto, based on number of threads. */
int i_subpel_ref ine; /* 亚像素运动估计质量*/
int b_chroma_me; /* 亚像素色度运动估计和P帧的模式选择*/
int b_mixed_ref erences; /*允许每个宏块的分区在P帧有它自己的参考号*/
int i_trellis; /* Trellis量化，对每个8x8的块寻找合适的量化值，需要CABAC，默认0 0：关闭1：只在最后编码时使用2：一直使用*/
int b_f ast_pskip; /*快速P帧跳过检测*/
int b_dct_decimate; /* 在P-f rames转换参数域*/
int i_noise_reduction; /*自适应伪盲区*/
f loat f_psy_rd; /* Psy RD strength */
f loat f_psy_trellis; /* Psy trellis strength */
int b_psy; /* T oggle all psy optimizations */
/*，亮度量化中使用的无效区大小*/
int i_luma_deadzone[2]; /* {帧间, 帧内} */
int b_psnr; /* 计算和打印PSNR信息*/
int b_ssim; /*计算和打印SSI M信息*/
} analyse;
/* 码率控制参数*/
struct
{
int i_rc_method; /* X264_RC_* */
int i_qp_constant; /* 0-51 */
int i_qp_min; /*允许的最小量化值*/
int i_qp_max; /*允许的最大量化值*/
int i_qp_step; /*帧间最大量化步长*/
int i_bitrate; /*设置平均码率*/
f loat f_rf_constant; /* 1pass VBR, nominal QP */
f loat f_rate_tolerance;
int i_v bv_max_bitrate; /*平均码率模式下，最大瞬时码率，默认0(与-B设置相同) */
int i_v bv_buff er_size; /*码率控制缓冲区的大小，单位kbit，默认0 */
f loat f_v bv_buff er_init; /* <=1: f raction of buff er_size. >1: kbit码率控制缓冲区数据保留的最大数据量与缓冲区大小之比，范围0~1.0，默认0.9*/
f loat f_ip_f actor;
f loat f_pb_f actor;
int i_aq_mode; /* psy adaptiv e QP. (X264_AQ_*) */
f loat f_aq_strength;
int b_mb_tree; /* Macroblock-tree ratecontrol. */
int i_lookahead;
/* 2pass 多次压缩码率控制*/
int b_stat_write; /* Enable stat writing in psz_stat_out */
char *psz_stat_out;
int b_stat_read; /* Read stat f rom psz_stat_in and use it */
char *psz_stat_in;
/* 2pass params (same as ffmpeg ones) */
f loat f_qcompress; /* 0.0 => cbr, 1.0 => constant qp */
f loat f_qblur; /*时间上模糊量化*/
f loat f_complexity_blur; /* 时间上模糊复杂性*/
x264_zone_t *zones; /* 码率控制覆盖*/
int i_zones; /* number of zone_t's */
char *psz_zones; /*指定区的另一种方法*/
} rc;
/* Muxing parameters */
int b_aud; /*生成访问单元分隔符*/
int b_repeat_headers; /* 在每个关键帧前放置SPS/PPS*/
int i_sps_id; /* SPS 和PPS id 号*/
/*切片（像条）参数*/
int i_slice_max_size; /* 每片字节的最大数，包括预计的NAL开销. */
int i_slice_max_mbs; /* 每片宏块的最大数，重写i_slice_count */
int i_slice_count; /* 每帧的像条数目: 设置矩形像条. */
/* Optional callback f or freeing this x264_param_t when it is done being used.
* Only used when the x264_param_t sits in memory f or an indef inite period of time,
* i.e. when an x264_param_t is passed to x264_t in an x264_picture_t or in zones.
* Not used when x264_encoder_reconf ig is called directly. */
void (*param_f ree)( v oid* );
} x264_param_t;
结构体定义区
/******************** * 结构体定义区 * ********************/ typedef struct PID { int16_t pConst; // 比例常数 Proportional Const int16_t iConst; // 积分常数 Integral Const int16_t dConst; // 微分常数 Derivative Const int16_t position; int16_t hisPosition; int16_t lastPosition[10]; }PID; /*********************************************************** * 函数名称：PID参数初始化 * 功能描述：初始化PID参数，并实现P、I、D三个参数的整定 * 参数列表： * 返回结果：无 ***********************************************************/ void PIDInit(PID *iPID) { memset(iPID, 0, sizeof(iPID)); //将所有值清零 iPID->pConst = 2; // 比例常数 Proportional Const iPID->iConst = 0; // 积分常数 Integral Const iPID->dConst = 8; // 微分常数 Derivative Const } /*********************************************************** * 函数名称：PID控制程序 * 功能描述： * 参数列表： * 返回结果：无 ***********************************************************/ void PIDCalc( PID *cPID) { int16_t pGain; //P增益
结构体指针
C++语言结构体和指针 指针也可以指向一个结构体，定义的形式一般为： struct结构体名*变量名; 下面是一个定义结构体指针的实例： 上述代码已经测试。 注意：定义已经命名的结构体指针的时候必须用已命名结构体类型定义的结构体变量的地址进行初始化。 也可以在定义结构体的同时定义结构体指针： 上述代码已经测试 注意，结构体变量名和数组名不同，数组名在表达式中会被转换为数组指针，而结构体变量名不会，无论在任何表达式中它表示的都是整个集合本身，要想取得结构体变量的地址，必 pstu赋值只能写作： struct stu *pstu = &stu1; 而不能写作： struct stu *pstu = stu1; 还应该注意，结构体和结构体变量是两个不同的概念：结构体是一种数据类型，是一种创建变量的模板，编译器不会为它分配内存空间，就像int、float、char 这些关键字本身不占用内存一样；结构体变量才包含实实在在的数据，才需要内存来存储。下面的写法是错误的，不可能去取一个结构体名的地址，也不能将它赋值给其他变量： struct stu *pstu = &stu; struct stu *pstu = stu;
获取结构体成员 通过结构体指针可以获取结构体成员，一般形式为： (*pointer).memberName 或者： pointer->memberName 对了。 ，有了它，可以通过结构体指针 直接取得结构体成员；这C语言中的唯一用途。 上面的两种写法是等效的，我们通常采用后面的写法，这样更加直观。
运行结果： Name Num Age Group Score Zhou ping 5 18 C 145.0 Zhang ping 4 19 A 130.5 Liu fang 1 18 A 148.5 Cheng ling 2 17 F 139.0 Wang ming 3 17 B 144.5 结构体指针作为函数参数 结构体变量名代表的是整个集合本身，作为函数参数时传递的整个集合，也就是所有成员，而不是像数组一样被编译器转换成一个指针。如果结构体成员较多，尤其是成员为数组时，传送的时间和空间开销会很大，影响程序的运行效率。所以最好的办法就是使用结构体指针，这时由实参传向形参的只是一个地址，非常快速。 要铭记的一点就是：数组名称始终代表数组的指针指向第一个元素，数组名称加一始终指向下一个数组元素。
C语言中指针和数组名的用法,结构体与共用体的总结
C语言中指针和数组名的用法,结构体与共用体的总结 2010-01-11 19:38 在C语言中，指针和数组名通常都可以混用。 例如 char *p; 访问时，*p跟p[0]是一样的，*(p+1)跟p[1]是一样的。 对于数组 char b[5]; 访问时，b[0]跟*b是一样的，b[2]跟*(b+2)是一样的。 在一般的通信中（例如串口），通常都使用字节传输。而像float，long int 之类的， 有4字节。我的方法就是取它的地址，强制转换为char型指针，然后当作数组来用。 float x; SBUF=((char*)&x)[0]; SBUF=((char*)&x)[1]; SBUF=((char*)&x)[2]; SBUF=((char*)&x)[3]; 接收时，刚好倒过来。 更有趣的是，对于数组形式，数组名和后面的偏移量可以随便换。 char buff[10]; //或者用 char *buff=&buffer; buff[3]=0xaa; 3[buff]=0xaa; //两者是一样的 因此，我认为编译器是这么做的：对于形如xxx[yyy]这样的表达式，会转化为*(xxx+yyy)， 因此写成xxx[yyy]或者写成yyy[xxx]都无所谓了... c语言结构体与共用体学习笔记1 Author:yuexingtian Date:Thursday, June 12, 2008 1结构变量的赋值 测试结果：
{ struct stu { int num; char *name; char sex; float score; }boy1,boy2; boy1.num=15; https://www.wendangku.net/doc/c89855448.html,="yuexingtian"; printf("input sex and score\n"); scanf("%c %f",&boy1.sex,&boy1.score); boy2=boy1; printf("Number=%d\nName=%s\n",boy2.num,https://www.wendangku.net/doc/c89855448.html,); printf("Sex=%c\nScore=%f\n",boy2.sex,boy2.score); getch(); } 说明： 本程序中用赋值语句给num和name两个成员赋值，name是一个字符串指针变量。用scanf函数动态地输入sex和score成员值，然后把boy1的所有成员的值整体赋予boy2。最后分别输出boy2的各个成员值。本例表示了结构变量的赋值、输入和输出的方法。 2结构变量的初始化 对结构变量的初始化（还拿上例举例）
结构体的使用方法
下面介绍了结构体的创建和使用方法： 创建过程： 定义一个名字为addr_t的结构体，其内容为名位addr的数组，数组大小为NET_ADDR_SIZE。 typedef struct { addr_t *addr;//地址 u8 *msg;//信息 u8 len;//信息长度 u8 port;//端口 } ioctlRawSend_t;//发送信息结构体 定义一个名字为ioctlRawSend_t的结构体，其内容为一个结构体，一个无符号类型指针和两个无符号数。将内容中的结构体代入这个结构体类型中，其内容可以写成（这样写只是为了看得更清晰） typedef struct { u8 addr[NET_ADDR_SIZE];//地址 u8 *msg;//信息 u8 len;//信息长度 u8 port;//端口 } ioctlRawSend_t;//发送信息结构体 这是一个联合体（共用体），很好理解，就是把两个结构体成员（ioctlRawSend_t，ioctlRawReceive_t）放在了一起用同一个名字（ioctl_info）表示，成员占用相同的内存单元，其中内容同步变化。 从变量观察窗口我们可以看到变量是如何组织在一起的。
到现在就从最基础的数组组成了一个联合体，下面我们使用它。 下面的语句中显示了如何向刚才建立的联合体中写要求的数据。 下面进行逐句分析 第一行中写广播地址（具体数字可以认为变动，一般为{0xFF,0xFF,0xFF,0xFF}）到联合体中的 发送地址中。下面是变量窗口中发生的变化（红色表示变化）。
接下来的一句为向信息中填充内容，下面是变量观察窗口的变化。其中msg只显示0号元素，是因为它是一个指针，指向的是首地址，其实其他的内容也已经变化。
c语言结构体用法(转载)
C语言，结构体(struct) 用法 结构(struct) 结构是由基本数据类型构成的、并用一个标识符来命名的各种变量的组合。 结构中可以使用不同的数据类型。 1. 结构说明和结构变量定义 在T urbo C中, 结构也是一种数据类型, 可以使用结构变量, 因此, 象其它 类型的变量一样, 在使用结构变量时要先对其定义。 定义结构变量的一般格式为: struct 结构名 { 类型变量名; 类型变量名; ... } 结构变量; 结构名是结构的标识符不是变量名。 类型为第二节中所讲述的五种数据类型(整型、浮点型、字符型、指针型和 无值型)。 构成结构的每一个类型变量称为结构成员, 它象数组的元素一样, 但数组中 元素是以下标来访问的, 而结构是按变量名字来访问成员的。
下面举一个例子来说明怎样定义结构变量。 struct string { char name[8]; int age; char sex[2]; char depart[20]; float wage1, wage2, wage3, wage4, wage5; } person; 这个例子定义了一个结构名为string的结构变量person, 如果省略变量名 person, 则变成对结构的说明。用已说明的结构名也可定义结构变量。这样定义 时上例变成: struct string { char name[8]; int age; char sex[2]; char depart[20]; float wage1, wage2, wage3, wage4, wage5; }; struct string person; 如果需要定义多个具有相同形式的结构变量时用这种方法比较方便, 它先作 结构说明, 再用结构名来定义变量。 例如: struct string T ianyr, Liuqi, ...; 如果省略结构名, 则称之为无名结构, 这种情况常常出现在函数内部, 用这 种结构时前面的例子变成:
结构体的定义及初始化
?结构体类型定义 struct [结构体名] { 类型标识符成员名； 类型标识符成员名； ……………. }；成员类型可以是基本型或构造型 struct是关键字,不能省略合法标识符 可省:无名结构体 结构体的说明及结构体变量的定义
例struct student { int num; char name[20]; char sex; int age; float score; char addr[30]; }; name num sex age score addr 2字节 2字节 20字节 1字节 4字节 30字节 … ….. 结构体类型定义描述结构 的组织形式,不分配内存 例子图解
?结构体类型定义 struct [结构体名] { 类型标识符成员名； 类型标识符成员名； ……………. }；成员类型可以是基本型或构造型 struct是关键字,不能省略合法标识符 可省:无名结构体 结构体的说明及结构体变量的定义
(1) 在结构体说明的同时定义结构体变量,例如：struct example { char *name； int age; }guo,zhang；(2)直接定义结构体变量,例如： struct {char *name； int age; }guo,zhang 未给 出结 构体 名 (3) 把定义和说明分开,例如：struct example { char *name； int age; }； struct example guo,zhang；结构体变量占用内存的大小可用sizeof()运算来求出 ?结构体变量的定义
结构体的说明及结构体变量的定义?变量说明形式 struct 结构体名结构体变量名； ?注意： 结构变量的存储类型概念、它的寿命、可见 性及使用范围与普通变量、数组等完全一致。 结构体变量说明必须在结构类型定义之后， 二者也可同时进行。
C语言中不同的结构体类型的指针间的强制转换详解
C语言中不同类型的结构体的指针间可以强制转换，很自由，也很危险。只要理解了其内部机制，你会发现C是非常灵活的。 一. 结构体声明如何内存的分布， 结构体指针声明结构体的首地址， 结构体成员声明该成员在结构体中的偏移地址。 变量的值是以二进制形式存储在内存中的，每个内存字节对应一个内存地址，而内存存储的值本身是没有整型，指针，字符等的区别的，区别的存在是因为我们对它们有不同的解读，param的值就是一个32位值，并且存储在某个内存单元中，通过这个32位值就能找到param所指向的结构的起始地址，通过这个起始地址和各个结构所包含变量离起始地址的偏移对这些变量进行引用， param->bIsDisable只是这种引用更易读的写法，只要param是指向 PAINT_PARAM的指针，那么param的值就肯定存在，param存在，偏移量已知，那么param->bIsDisable就肯定存在，只是要记住，param->bIsDisable只是代表了对param一定偏移地址的值。 不是说某个地址有那个结构体你才能引用，即使没有，你也能引用，因为你已经告诉了编译器param变量就是指向一个PAINT_PARAM结构体的变量并且指明了param的值，机器码的眼中是没有数据结构一说的，它只是机械的按照 指令的要求从内存地址取值，那刚才的例子来说，peg->x,peg->y的引用无论 0x30000000是否存在一个eg结构体都是合法的，如果0x30000000开始的8 个字节存在eg结构体，那么引用的就是这个结构体的值，如果这个位置是未定义的值，那么引用的结果就是这8个字节中的未定义值，内存位置总是存在的，而对内存中值的引用就是从这些内存位置对应的内存单元取值。 举个例子: typedefstruct_eg { int x； int y； }eg;
结构体的指针应用
什么是结构体？ 简单的来说，结构体就是一个可以包含不同数据类型的一个结构，它是一种可以自己定义的数据类型，它的特点和数组主要有两点不同，首先结构体可以在一个结构中声明不同的数据类型，第二相同结构的结构体变量是可以相互赋值的，而数组是做不到的，因为数组是单一数据类型的数据集合，它本身不是数据类型(而结构体是)，数组名称是常量指针，所以不可以作为左值进行运算，所以数组之间就不能通过数组名称相互复制了，即使数据类型和数组大小完全相同。 定义结构体使用struct修饰符，例如： struct test { float a; int b; }; 上面的代码就定义了一个名为test的结构体，它的数据类型就是test，它包含两个成员a和b，成员a的数据类型为浮点型，成员b的数据类型为整型。由于结构体本身就是自定义的数据类型，定义结构体变量的方法和定义普通变量的方法一样。 test pn1; 这样就定义了一个test结构体数据类型的结构体变量pn1，结构体成员的访问通过点操作符进行，pn1.a=10 就对结构体变量pn1的成员a进行了赋值操作。注意:结构体生命的时候本身不占用任何内存空间，只有当你用你定义的结构体类型定义结构体变量的时候计算机才会分配内存。 结构体，同样是可以定义指针的，那么结构体指针就叫做结构指针。 结构指针通过->符号来访问成员，下面我们就以上所说的看一个完整的例子： #include
指针和结构体练习题.
第十章指针 一．选择题 1.变量的指针，其含义是指该变量的。 A）值 B）地址 C）名 D）一个标志 2.已有定义int k=2;int *ptr1,*ptr2;且ptr1和ptr2均已指向变量k，下面不能正确执行的赋值语句是。 A）k=*ptr1+*ptr2 B）ptr2=k C）ptr1=ptr2 D）k=*ptr1*(*ptr2 3.若有说明：int *p,m=5,n;以下程序段正确的是。 A）p=&n ; B）p = &n ; scanf(“%d”,&p; scanf(“%d”,*p; C）scanf(“%d”,&n; D）p = &n ; *p=n ; *p = m ; 4.已有变量定义和函数调用语句：int a=25;print_value(&a;下面函数的输出结果是。 void print_value(int *x { printf(“%d\n”,++*x; } A）23 B）24 C）25 D）26 5.若有说明：int *p1, *p2,m=5,n;以下均是正确赋值语句的选项是。 A）p1=&m; p2=&p1 ; B）p1=&m; p2=&n; *p1=*p2 ; C）p1=&m; p2=p1 ; D）p1=&m; *p1=*p2 ; 6.若有语句：int *p,a=4;和p=&a；下面均代表地址的一组选项是。 A）a,p,*&a B）&*a,&a,*p C）*&p,*p,&a D）&a,&*p,p 7.下面判断正确的是。 A）char *a=”china”; 等价于char *a; *a=”china” ; B）char str[10]={“china”}; 等价于char str[10]; str[ ]={“china”;}
C语言结构体习题及答案
第9章结构体 1．定义以下结构体类型 struct s { int a; char b; float f; }; 则语句printf("%d",sizeof(struct s))的输出结果为【】。 A) 3 B) 7 C) 6 D) 4 2．当定义一个结构体变量时，系统为它分配的内存空间是【】 A）结构中一个成员所需的内存容量 B）结构中第一个成员所需的内存容量 C）结构体中占内存容量最大者所需的容量 D）结构中各成员所需内存容量之和 3．定义以下结构体类型 struct s { int x; float f; }a[3]; 语句printf("%d",sizeof(a))的输出结果为【】 A) 4 B) 12 C) 18 D) 6 4．定义以下结构体数组 struct c { int x; int y; }s[2]={1,3,2,7}; 语句printf("%d",s[0].x*s[1].x)的输出结果为【】 A) 14 B) 6 C) 2 D) 21 5．运行下列程序段，输出结果是【】 struct country { int num; char name[10]; }x[5]={1,"China",2,"USA",3,"France",4, "England",5, "Spanish"}; struct country *p; p=x+2; printf("%d,%c",p->num,(*p).name[2]); A) 3,a B) 4,g C) 2,U D) 5,S
6．下面程序的运行结果是【】。 struct KeyWord { char Key[20]; int ID; }kw[]={"void",1,"char",2,"int",3,"float",4,"double",5}; main() { printf("%c,%d\n",kw[3].Key[0], kw[3].ID); } A) i,3 B) n,3 C) f,4 D) l,4 7．定义以下结构体类型 struct student { char name[10]; int score[50]; float average; }stud1; 则stud1占用内存的字节数是【】。 A) 64 B) 114 C) 228 D) 7 8．如果有下面的定义和赋值，则使用【】不可以输出n中data的值。struct SNode { unsigned id; int data; }n,*p; p=&n; A) p.data B) n.data C) p->data D) (*p).data 9.根据下面的定义，能输出Mary的语句是【】。 struct person { char name[9]; int age; }; struct person class[5]={"John",17,"Paul",19,"Mary",18,"Adam",16}; A) printf("%s\n",class[1].name); B) printf("%s\n",class[2].name); C) printf("%s\n",class[3].name);
C语言入门教程-指向结构体的指针
C语言入门教程-指向结构体的指针 2009年07月29日12:04 [导读] 指向结构体的指针 在C语言中几乎可以创建指向任何类型的指针，包括用户自定义的类型。创建结构体指针是极常见的。下面是一个例子： typedef struct{
关键词：c语言入门 指向结构体的指针 在C语言中几乎可以创建指向任何类型的指针，包括用户自定义的类型。创建结构体指针是极常见的。下面是一个例子： typedef struct
{char name[21];char city[21];char state[3];} Rec; typedef Rec *RecPointer; RecPointer r; r=(RecPointer)malloc(sizeof(Rec)); r是一个指向结构体的指针。请注意，因为r是一个指针，所以像其他指针一样占用4个字节的内存。而malloc语句会从堆上分配45字节的内存。*r是一个结构体，像任何其他Rec类型的结构体一样。下面的代码显示了这个指针变量的典型用法：
strcpy((*r).city, "Raleigh"); strcpy((*r).state, "NC"); printf("%sn", (*r).city); free(r); 您可以像对待一个普通结构体变量那样对待*r，但在遇到C的操作符优先级问题时要小心。如果去掉*r两边的括号则代码将无法编译，因为“.”操作符的优先级高于“*”操作符。使用结构体指针时不断地输入括号是令人厌烦的，为此C语言引入了一种简记法达到相同的目的：
r->这种写法和(*r).是完全等效的，但是省去了两个字符。 指向数组的指针 还可以创建指向数组的指针，如下所示：
指针在结构体中的应用.
实验14 指针在结构体中的应用 一、实验目的 1．掌握结构体类型指针的定义及使用方法。 2．掌握结构体类型指针作为函数参数，实现函数调用。 3．掌握简单链表的基本操作。 二、实验要求 1．通过阅读及编程，掌握结构体类型指针的定义及使用方法。 2．通过阅读及编程，掌握结构体类型指针作为函数参数，实现函数调用。 3．通过阅读及编程，掌握简单链表的基本操作（包括链表的建立、查找、遍历、插入、删除）。 三、实验内容 1．阅读下列程序，预测程序运行结果，然后上机验证。 main （） { struct num { int a ; int b ; float f ; } n={ 1 , 3, 5.0 }; struct num * pn =&n ; printf ( “ %d\n ” , ( pn->b/n.a )*(++pn ->b) ); printf ( “ %f \n ” , ( *pn ).a + pn ->f ); } 1．读下列程序，指出程序的功能。 struct tm { int hours ; int minutes ; int seconds ; }; main ( ) { struct tm time ; time. hours=0 ; time. minutes =0; time . seconds =0 ;
for ( ; ; ) { update ( &time ); display (&time ); } } update ( struct tm * t ) { t-> seconds++; if ( t-> seconds= =60 ) { t-> seconds=0; t-> minues++; } if ( t-> minues= =60 ) { t-> minues=0; t-> hours++; } if ( t-> hours= =24 ) t-> hours=0; deday ( )； } display ( struct tm * t ) { printf ( “%d: ” , t-> hours ); printf ( “%d: ” , t-> minutes ); printf ( “%d:\n” , t-> seconds ); } delay ( ) { long int t; for ( t=1; t<12800 ; ++t ); } 3. 阅读并运行下列程序，写出运行结果。 #include “stdio.h” main ( ) { struct person { char name[20];
C语言复习题指针结构体
C语言复习题_指针&结构体 一、选择 1、若有以下定义：char s[20]="programming",*ps=s; 则不能代表字符'o'的表达式是A。 A) ps+2 B) s[2] C) ps[2] D) ps+=2,*ps 2、若有以下定义和语句: int a[10]={1,2,3,4,5,6,7,8,9,10},*p=a;则不能表示a数组元素的表达式是B。 A) *p B) a[10] C) *a D) a[p-a] 3、已知int *p,a; p=&a; 这里的运算符& 的含义D。 A) 位与运算B) 逻辑与运算C) 取指针内容D) 取变量地址 4、定义结构体如下： struct student { int num; char name[4]; int age; }; 则printf(“%d”,sizeof(struct student))的结果为: 12。 5、若有定义如下:int i=3,*p=&i; 显示i的值的正确语句是B。 A) printf(“%d”,p); B) printf(“%d”,*p); C) printf(“%p”,*p); D) printf(“%p”,p); 6、在定义结构体时，下列叙述正确的是A。 A) 系统不会分配空间 B) 系统会按成员大小分配空间 C) 系统会按最大成员大小分配空间 D) 以上说法均不正确 7、指针是一种D。 A) 标识符B) 变量C) 运算符D) 内存地址 8、定义struct s {int x; char y[6];} s1;,请问正确的赋值是C。 A) s1.y=”abc”; B) s1->y=”abc”; C) strcpy(s1.y,”abc”); D) s1.strcpy(y,”abc”); 9、已知定义“int x ＝1, *p”，则合法的赋值表达式是A。 A) p ＝&x B) p = x C) *p ＝&x D) *p ＝*x
C语言-基础教程-结构体类型变量的定义和引用
C语言-基础教程-结构体类型变量的定义和引用 前面的课程我们学习了一些简单数据类型（整型、实型、字符型）的定义和应用，还学习了数组（一维、二维）的定义和应用，这些数据类型的特点是：当定义某一特定数据类型，就限定该类型变量的存储特性和取值范围。对简单数据类型来说，既可以定义单个的变量，也可以定义数组。而数组的全部元素都具有相同的数据类型，或者说是相同数据类型的一个集合。 在日常生活中，我们常会遇到一些需要填写的登记表，如住宿表、成绩表、通讯地址等。 在这些表中，填写的数据是不能用同一种数据类型描述的，在住宿表中我们通常会登记上姓名、性别、身份证号码等项目；在通讯地址表中我们会写下姓名、邮编、邮箱地址、电话号码、E - m a i l等项目。这些表中集合了各种数据，无法用前面学过的任一种数据类型完全描述，因此C引入一种能集中不同数据类型于一体的数据类型-结构体类型。结构体类型的变量可以拥有不同数据类型的成员，是不同数据类型成员的集合。 在上面描述的各种登记表中，让我们仔细观察一下住宿表、成绩表、通讯地址等。 住宿表由下面的项目构成： 这些登记表用C提供的结构体类型描述如下： 住宿表: suct accommod { char name[20]; / *姓名* / char sex; / *性别* / char job[40]; / *职业* / int age; / *年龄* / long number; / *身份证号码* / } ; 成绩表: suct score
{ char grade[20]; / * 班级* / long number; / * 学号* / char name[20]; / *姓名* / float os; / *操作系统* / float datasu; / * 数据结构* / float compnet; / * 计算机网络* / } ; 通讯地址表: suct addr { char name[20]; char department[30];/ * 部门* / char address[30]; / *住址* / long box; / * 邮编* / long phone; / * 电话号码* / char email[30]; / * E m a i l * / }；
(1)定义结构体的关键字是
(1) 定义结构体的关键字是，定义共用体的关键字是。 (2) 结构体和共用体的相同点是，不同点是。 (3) 若有以下定义和语句，则sizeof(a)的值是__ ___，而sizeof(b)的值是__ _。struct tu { int m; char n; int y;}a; struct { float p, char q; struct tu r} b; (4) 设有下面结构类型说明和变量定义，则变量a在内存所占字节数是。如果将该结构改成共用体，结果为。 struct stud { char num[6]; int s[4]; double ave; } a; (5) 下面程序用来输出结构体变量ex所占存储单元的字节数，请填空。 struct st { char name[20]; double score; }; main() { struct st ex ; printf("ex size: %d\n",sizeof( )); } (6) 下面定义的结构体类型拟包含两个成员,其中成员变量info用来存入整形数据;成员变量link是指向自身结构体的指针,请将定义补充完整。 struct node { int info; link; } (7) 以下程序执行后输出结果是。 main() { union { unsigned int n; unsigned char c; } u1; u1.c='A'; printf("%c\n",u1.n); } (8) 变量root如图所示的存储结构，其中sp是指向字符串的指针域，next是指向该结构的指针域，data用以存放整型数。请填空，完成此结构的类型说明和变量root的定义。 root struct { char *sp ; __ __; _ _; } root; 2. 阅读下面的程序，写出程序结果 (1) struct info { char a,b,c;}; main() { struct info s[2]={{‘a’,‘b’,‘c’},{‘d’,‘e’,‘f’}};int t; t=(s[0].b-s[1].a)+(s[1].c-s[0].b); printf("%d\n",t); } (2)
c语言结构体指针初始化===
c语言结构体指针初始化 今天来讨论一下C中的内存管理。 记得上周在饭桌上和同事讨论C语言的崛起时，讲到了内存管理方面 我说所有指针使用前都必须初始化，结构体中的成员指针也是一样 有人反驳说，不是吧，以前做二叉树算法时，他的左右孩子指针使用时难道有初始化吗 那时我不知怎么的想不出理由，虽然我还是坚信要初始化的 过了几天这位同事说他试了一下，结构体中的成员指针不经过初始化是可以用（左子树和右子树指针） 那时在忙着整理文档，没在意 今天抽空调了一下，结论是，还是需要初始化的。 而且，不写代码你是不知道原因的（也许是对着电脑久了IQ和记性严重下跌吧） 测试代码如下 1.#include 2.#include 3.#include 4. 5.struct student{ 6.char *name; 7.int score; 8.struct student* next; 9.}stu,*stu1; 10. 11.int main(){ 12. https://www.wendangku.net/doc/c89855448.html, = (char*)malloc(sizeof(char)); /*1.结构体成员指针需要初始化*/ 13. strcpy(https://www.wendangku.net/doc/c89855448.html,,"Jimy"); 14. stu.score = 99; 15. 16. stu1 = (struct student*)malloc(sizeof(struct student));/*2.结构体指针需要初始化*/ 17. stu1->name = (char*)malloc(sizeof(char));/*3.结构体指针的成员指针同样需要初始化*/ 18. stu.next = stu1; 19. strcpy(stu1->name,"Lucy"); 20. stu1->score = 98; 21. stu1->next = NULL; 22. printf("name %s, score %d \n ",https://www.wendangku.net/doc/c89855448.html,, stu.score); 23. printf("name %s, score %d \n ",stu1->name, stu1->score); 24. free(stu1); 25.return 0; 26.} #include #include #include struct student{ char *name; int score; struct student* next; }stu,*stu1; int main(){ https://www.wendangku.net/doc/c89855448.html, = (char*)malloc(sizeof(char)); /*1.结构体成员指针需要初始化*/ strcpy(https://www.wendangku.net/doc/c89855448.html,,"Jimy"); stu.score = 99; stu1 = (struct student*)malloc(sizeof(struct student));/*2.结构体指针需要初始化*/ stu1->name = (char*)malloc(sizeof(char));/*3.结构体指针的成员指针同样需要初始化*/ stu.next = stu1; strcpy(stu1->name,"Lucy"); stu1->score = 98; stu1->next = NULL; printf("name %s, score %d \n ",https://www.wendangku.net/doc/c89855448.html,, stu.score);
C语言结构体(struct)常见使用方法
C语言结构体（struct）常见使用方法 基本定义：结构体，通俗讲就像是打包封装，把一些有共同特征（比如同属于某一类事物的属性，往往是某种业务相关属性的聚合）的变量封装在内部，通过一定方法访问修改内部变量。 结构体定义： 第一种：只有结构体定义 [cpp]view plain copy 1.struct stuff{ 2.char job[20]; 3.int age; 4.float height; 5.}; 第二种：附加该结构体类型的“结构体变量”的初始化的结构体定义 [cpp]view plain copy 1.//直接带变量名Huqinwei 2.struct stuff{ 3.char job[20]; 4.int age; 5.float height; 6.}Huqinwei; 也许初期看不习惯容易困惑，其实这就相当于： [cpp]view plain copy 1.struct stuff{ 2.char job[20]; 3.int age;
4.float height; 5.}; 6.struct stuff Huqinwei; 第三种：如果该结构体你只用一个变量Huqinwei，而不再需要用 [cpp]view plain copy 1.struct stuff yourname; 去定义第二个变量。 那么，附加变量初始化的结构体定义还可进一步简化出第三种： [cpp]view plain copy 1.struct{ 2.char job[20]; 3.int age; 4.float height; 5.}Huqinwei; 把结构体名称去掉，这样更简洁，不过也不能定义其他同结构体变量了——至少我现在没掌握这种方法。 结构体变量及其内部成员变量的定义及访问： 绕口吧？要分清结构体变量和结构体内部成员变量的概念。 就像刚才的第二种提到的，结构体变量的声明可以用： [cpp]view plain copy 1.struct stuff yourname; 其成员变量的定义可以随声明进行： [cpp]view plain copy 1.struct stuff Huqinwei = {"manager",30,185}; 也可以考虑结构体之间的赋值： [cpp]view plain copy
c语言结构体定义结构体
c语言结构体定义结构体 代码1 定义结构体_m_usmart_devstruct _m_usmart_dev{struct _m_usmart_nametab *funs;//函数名指针 void (*init)(u8);//初始化u8 (*cmd_rec)(u8*str);//识别函数名及参数void (*exe) (void); //执行void (*scan)(void); //扫描u8 fnum; //函数数量u8 pnum; //参数数 量u8 id;//函数idu8 sptype;//参数显示类型(非字符串参数):0,10 进制;1,16 进制; u16 parmtype;//参数的类型u8 plentbl[MAX_PARM]; //每个参数的长度暂存表u8 parm[PARM_LEN]; //函数的参数}; 代码2 定义_m_usmart_dev 类型的结构体并对其赋初始值 struct _m_usmart_dev usmart_dev={usmart_nametab,usmart_init,usmart_cmd_rec,usmart_exe,usmart_scan, sizeof(usmart_nametab)/sizeof(struct _m_usmart_nametab),//函数数量0, //参数数 量0, //函数ID1,//参数显示类型,0,10 进制;1,16 进制0,//参数类型.bitx:,0,数字;1, 字符串0, //每个参数的长度暂存表,需要MAX_PARM 个0 初始化0,//函数的参 数,需要PARM_LEN 个0 初始化}; 上边代码可理解为 struct _m_usmart_dev{struct _m_usmart_nametab *funs;//函数名指针 void (*init)(u8);//初始化u8 (*cmd_rec)(u8*str);//识别函数名及参数void (*exe) (void); //执行void (*scan)(void); //扫描u8 fnum; //函数数量u8 pnum; //参数数 量u8 id;//函数idu8 sptype;//参数显示类型(非字符串参数):0,10 进制;1,16 进制; u16 parmtype;//参数的类型u8 plentbl[MAX_PARM]; //每个参数的长度暂存表u8 parm[PARM_LEN]; //函数的参数} usmart_dev={usmart_nametab,usmart_init,usmart_cmd_rec,usmart_exe,usmart_scan,
C语言结构指针
C语言结构指针 这篇文章是九九年写的，这篇文章适合中级程序员。有不明白之处不要紧，多看几遍，然后花些时间上机操作及认真思考每个问题。遇到难题要研究、解决，难题出现于哪里？该用什么方式来解决？为什么要选择这个方式解决？有其它的解决方法吗？这样的解决方案完美吗？其实做个程序员这些基本的思考心得是要掌握的。记住；遇问题不要逃避，要面对现实、勇于挑战，仔细研究难题的所在，这样相信你会成功的！ 指针结构与指针的关系亦有两重：其一是在定义结构时，将指针作为结构中的一个成员；其二是指向结构的指针（称为结构指针）。前者同一般的结构成员一样可直接进行访问，后者是本节讨论的重点。 结构指针说明的一般形式是： struct 结构类型名称* 结构指针变量名； 例如：struct date * pdate, today; 说明了两个变量，一个是指向结构date的结构指针pdate，today是一个date结构变量。语句： pdate = &today; pdate today (struct date) year month day 通过结构变量today访问其成员的操作，也可以用等价的指针形式表示： today.year = 2001;等价于(*pdate).year = 2001;
由于运算符"*"的优先级比运算符"."的优先级低，所以必须有"( )"将*pdate括起来。若省去括号，则含义就变成了"*(pdate.year)"。 在Ｃ语言中，通过结构指针访问成员可以采用运算符"->"进行操作，对于指向结 构的指针，为了访问其成员可以采用下列语句形式： 结构指针->成员名; 这样，上面通过结构指针pdate访问成员year的操作就可以写成： pdate->year = 2001; 如果结构指针p指向一个结构数组，那么对指针p的操作就等价于对数组下标的操作。 结构指针是指向一种结构类型的指针变量，它是结构在内存中的首地址，结构指针具有一般指针的特性，如在一定条件下两个指针可以进行比较，也可以与整数进行加减。但在指针操作时应注意：进行地址运算时的放大因子由所指向的结构的实际大小决定。 例11-7：用结构指针改写加密程序。 #include "stdio.h" struct table { char input, output; } ; struct table translate[ ]= { 'a', 'd', 'b', 'w', 'c', 'k', 'd', ';' , 'e', 'i', 'i', 'a', 'k', 'b', ';', 'c', 'w', 'e' }; /* 建立加密对照表*/ main( ) { char ch; struct table *p, *pend; /* p和pend为指向结构table的指针*/ pend = & translate[ sizeof(translate)/sizeof(struct table)-1 ]; /* pend指向结构数组translate的最后一个元素*/ while ( (ch=getchar( )) != '\n')