转载C#中继承实现父类方法、重写、重载
【转载】C代码优化方案
【转载】C代码优化⽅案C代码优化⽅案1、选择合适的算法和数据结构2、使⽤尽量⼩的数据类型3、减少运算的强度 (1)查表(游戏程序员必修课) (2)求余运算 (3)平⽅运算 (4)⽤移位实现乘除法运算 (5)避免不必要的整数除法 (6)使⽤增量和减量操作符 (7)使⽤复合赋值表达式 (8)提取公共的⼦表达式4、结构体成员的布局 (1)按数据类型的长度排序 (2)把结构体填充成最长类型长度的整倍数 (3)按数据类型的长度排序本地变量 (4)把频繁使⽤的指针型参数拷贝到本地变量5、循环优化 (1)充分分解⼩的循环 (2)提取公共部分 (3)延时函数 (4)while循环和do…while循环 (6)循环展开 (6)循环嵌套 (7)Switch语句中根据发⽣频率来进⾏case排序 (8)将⼤的switch语句转为嵌套switch语句 (9)循环转置 (10)公⽤代码块 (11)提升循环的性能 (12)选择好的⽆限循环6、提⾼CPU的并⾏性 (1)使⽤并⾏代码 (2)避免没有必要的读写依赖7、循环不变计算8、函数 (1)Inline函数 (2)不定义不使⽤的返回值 (3)减少函数调⽤参数 (4)所有函数都应该有原型定义 (5)尽可能使⽤常量(const) (6)把本地函数声明为静态的(static)9、采⽤递归10、变量 (1)register变量 (2)同时声明多个变量优于单独声明变量 (3)短变量名优于长变量名,应尽量使变量名短⼀点 (4)在循环开始前声明变量11、使⽤嵌套的if结构1、选合适的算法和数据结构选择⼀种合适的数据结构很重要,如果在⼀堆随机存放的数中使⽤了⼤量的插⼊和删除指令,那使⽤链表要快得多。
数组与指针语句具有⼗分密切的关系,⼀般来说,指针⽐较灵活简洁,⽽数组则⽐较直观,容易理解。
对于⼤部分的编译器,使⽤指针⽐使⽤数组⽣成的代码更短,执⾏效率更⾼。
在许多种情况下,可以⽤指针运算代替数组索引,这样做常常能产⽣⼜快⼜短的代码。
转载:C语言指针使用的注意事项
转载:C语⾔指针使⽤的注意事项相信⼤家对指针的⽤法已经很熟了,这⾥也不多说些定义性的东西了,只说⼀下指针使⽤中的注意事项吧。
⼀.在定义指针的时候注意连续声明多个指针时容易犯的错误,例如int * a,b;这种声明是声明了⼀个指向int类型变量的指针a和⼀个int型的变量b,这时候要清醒的记着,⽽不要混淆成是声明了两个int型指针。
⼆.要避免使⽤未初始化的指针。
很多运⾏时错误都是由未初始化的指针导致的,⽽且这种错误⼜不能被编译器检查所以很难被发现。
这时的解决办法就是尽量在使⽤指针的时候定义它,如果早定义的化⼀定要记得初始化,当然初始化时可以直接使⽤cstdlib中定义的NULL也可以直接赋值为0,这是很好的编程习惯。
三.指针赋值时⼀定要保证类型匹配,由于指针类型确定指针所指向对象的类型,因此初始化或赋值时必须保证类型匹配,这样才能在指针上执⾏相应的操作。
四.void * 类型的指针,其实这种形式只是记录了⼀个地址罢了,如上所说,由于不知道所指向的数据类型是什么所以不能进⾏相应的操作。
其实void * 指针仅仅⽀持⼏种有限的操作:1.与另外的指针进⾏⽐较,因为void *类型⾥⾯就是存的⼀个地址,所以这点很好理解;2.向函数传递void *指针或从函数返回void *指针,举个例⼦吧,我们平时常⽤的库函数qsort中的⽐较函数cmp(个⼈习惯于⽤这个名字)中传递的两个参数就是const void *类型的,⽤过的应该很熟了;3.给另⼀个void * 类型的指针赋值。
还是强调⼀下不能使⽤void * 指针操纵它所指向的对象。
五.不要将两个指针变量指向同⼀块动态内存。
这个容易引起很严重的问题。
如果将两个指针变量指向同⼀块动态内存,⽽其中⼀个⽣命期结束释放了该动态内存,这个时候就会出现问题,另⼀个指针所指向的地址虽然被释放了但该指针并不等于NULL,这就是所谓的悬垂指针错误,这种错误很难被察觉,⽽且⾮常严重,因为这时该指针的值是随机的,可能指向⼀个系统内存⽽导致程序崩溃。
C++开源项目汇总(转载)
C++开源项⽬汇总(转载)转⾃值得学习的C/C++语⾔开源项⽬(1)ACE庞⼤、复杂,适合⼤型项⽬。
开源、免费,不依赖第三⽅库,⽀持。
(2)AsioAsio基于Boost开发的异步IO库,封装了Socket,简化基于socket程序的开发。
开源、免费,⽀持。
(3)POCOPOCO C++ Libraries 提供⼀套 C++ 的类库⽤以开发基于⽹络的可移植的应⽤程序,功能涉及线程、线程同步、⽂件系统访问、流操作、共享库和类加载、套接字以及⽹络协议包括:HTTP、 FTP、SMTP 等;其本⾝还包含⼀个 HTTP ,提供 XML 的解析和 SQL 数据库的访问接⼝。
POCO库的模块化、⾼效的设计及实现使得POCO特别适合嵌⼊式开发。
在嵌⼊式开发领域,由于C++既适合底层(设备I/O、中断处理等)和⾼层⾯向对象开发,越来越流⾏。
(4)libeventLibevent是⼀个轻量级的开源⾼性能⽹络库,从它的官⽹标题:libevent-an event notification library就能知道它的机制是采⽤事件触发,封装了以下三种事件的响应:IO事件,定时器事件,信号事件。
select模型来实现的操作,Windows环境下⽀持IOCP。
(5)libevlibev和libevent很像,按照作者的介绍,可以作为libevent的替代者,能够提供更⾼的性能。
libev是⼀个⾼性能事件循环,所实现的功能就是⼀个强⼤的reactor。
(6)c++ sockets library封装了sockets C API的C++类库。
⽀持SSL, IPv6, tcp 和 udp sockets, sctp sockets, http协议, ⾼度可定制的错误处理。
(7)libcurllibcurl是免费的轻量级的客户端⽹络库,⽀持DICT, FILE, FTP, FTPS, Gopher, HTTP, HTTPS, IMAP, IMAPS, LDAP, LDAPS, POP3,POP3S, RTMP, RTSP, SCP, SFTP, SMTP, SMTPS, Telnet, TFTP. ⽀持SSL, HTTP POST, HTTP PUT, FTP上传, HTTP form上传,代理,cookies, ⽤户名与密码认证。
C类论文指定期刊刊名
附件1:A、A1、B、C类论文指定期刊刊名一、A类论文(国际权威期刊)1.Nature(英)2.Science(美)二、A1类论文1.《中国科学》2.《中国社会科学》三、B类论文SCI、EI刊源期刊(当年最新版)四、C类论文1.《中文核心期刊要目总览》所列举的核心期刊2.《科技核心期刊要目总览》所列举的核心期刊附件2:转载、文摘等检索性刊物等级A类:1.科学引文索引(Science Citation Index, SCI)2.科学与技术会议录索引(Index to scientific & Technical Proceedings, ISTP)3.工程索引(Engineering Index, EI)4.社会科学引文索引(Social Science Citation Index, SSCI)5.社会科学及人文科学会议录索引(Index to Social Science & Humanities Proceeding, ISSHP)6. 中文社会科学引文索引(Chinese Social Science Citation Information,CSSCI)B类:1.新华文摘(3000字以上文摘)2.中国社会科学文摘(3000字以上文摘)3.《中国社会科学》英文版C类:1.新华文摘(3000字以下的文摘)2.中国社会科学文摘(3000字以下文摘)3.人大复印资料(全文转载)附件3:成都职业技术学院科研工作先进集体申报表_______年度附件4:成都职业技术学院科研先进集体成果计分统计表申报单位(公章)部门负责人(签字): 统计人(签字):。
C语言中的sscanf用法(转载)
C语⾔中的sscanf⽤法(转载)sscanf名称: sscanf() - 从⼀个字符串中读进与指定格式相符的数据. 函数原型函数原型: Int sscanf( string str, string fmt, mixed var1, mixed var2 ... ); int scanf( const char *format [,argument]... ); 说明:说明: sscanf与scanf类似,都是⽤于输⼊的,只是后者以屏幕(stdin)为输⼊源,前者以固定字符串为输⼊源。
其中的format可以是⼀个或多个 {%[*] [width] [{h | l | I64 | L}]type | ' ' | '\t' | '\n' | ⾮%符号} 注:注: 1、 * 亦可⽤于格式中, (即 %*d 和 %*s) 加了星号 (*) 表⽰跳过此数据不读⼊. (也就是不把此数据读⼊参数中) 2、{a|b|c}表⽰a,b,c中选⼀,[d],表⽰可以有d也可以没有d。
3、width表⽰读取宽度。
4、{h | l | I64 | L}:参数的size,通常h表⽰单字节size,I表⽰2字节 size,L表⽰4字节size(double例外),l64表⽰8字节size。
5、type :这就很多了,就是%s,%d之类。
6、特别的:%*[width] [{h | l | I64 | L}]type 表⽰满⾜该条件的被过滤掉,不会向⽬标参数中写⼊值 ⽀持集合操作:⽀持集合操作: %[a-z] 表⽰匹配a到z中任意字符,贪婪性(尽可能多的匹配) %[aB'] 匹配a、B、'中⼀员,贪婪性 %[^a] 匹配⾮a的任意字符,贪婪性[]例⼦:1. 常见⽤法。
char buf[512] = ; sscanf("123456 ", "%s", buf); printf("%s\n", buf); 结果为:123456 2. 取指定长度的字符串。
[转载整理]C语言链表实例
[转载整理]C语⾔链表实例 C语⾔链表有单链表、双向链表、循环链表。
单链表由数据域和指针域组成,数据域存放数据,指针域存放该数据类型的指针便于找到下⼀个节点。
双链表则含有头指针域、数据域和尾指针域,域单链表不同,双链表可以从后⼀个节点找到前⼀个节点,⼆单链表则不⾏。
循环链表就是在单链表的基础上,将头结点的地址指针存放在最后⼀个节点的指针域⾥以,此形成循环。
此外还有双向循环链表,它同时具有双向链表和循环链表的功能。
单链表如:链表节点的数据结构定义struct node{int num;struct node *p;} ;在此链表节点的定义中,除⼀个整型的成员外,成员p是指向与节点类型完全相同的指针。
※在链表节点的数据结构中,⾮常特殊的⼀点就是结构体内的指针域的数据类型使⽤了未定义成功的数据类型。
这是在C中唯⼀规定可以先使⽤后定义的数据结构。
链表实例代码:1// 原⽂地址 /wireless-dragon/p/5170565.html2 #include<stdio.h>3 #include<stdlib.h>4 #include<string.h>56 typedef int elemType;//定义存⼊的数据的类型可以是int char78 typedef struct NODE{ //定义链表的结构类型9 elemType element;10struct NODE *next;11 }Node;1213/************************************************************************/14/* 以下是关于线性表链接存储(单链表)操作的19种算法 */1516/* 1.初始化线性表,即置单链表的表头指针为空 */17/* 2.创建线性表,此函数输⼊负数终⽌读取数据*/18/* 3.打印链表,链表的遍历*/19/* 4.清除线性表L中的所有元素,即释放单链表L中所有的结点,使之成为⼀个空表 */20/* 5.返回单链表的长度 */21/* 6.检查单链表是否为空,若为空则返回1,否则返回0 */22/* 7.返回单链表中第pos个结点中的元素,若pos超出范围,则停⽌程序运⾏ */23/* 8.从单链表中查找具有给定值x的第⼀个元素,若查找成功则返回该结点data域的存储地址,否则返回NULL */24/* 9.把单链表中第pos个结点的值修改为x的值,若修改成功返回1,否则返回0 */25/* 10.向单链表的表头插⼊⼀个元素 */26/* 11.向单链表的末尾添加⼀个元素 */27/* 12.向单链表中第pos个结点位置插⼊元素为x的结点,若插⼊成功返回1,否则返回0 */28/* 13.向有序单链表中插⼊元素x结点,使得插⼊后仍然有序 */29/* 14.从单链表中删除表头结点,并把该结点的值返回,若删除失败则停⽌程序运⾏ */30/* 15.从单链表中删除表尾结点并返回它的值,若删除失败则停⽌程序运⾏ */31/* 16.从单链表中删除第pos个结点并返回它的值,若删除失败则停⽌程序运⾏ */32/* 17.从单链表中删除值为x的第⼀个结点,若删除成功则返回1,否则返回0 */33/* 18.交换2个元素的位置 */34/* 19.将线性表进⾏冒排序 */35363738/*注意检查分配到的动态内存是否为空*/3940414243/* 1.初始化线性表,即置单链表的表头指针为空 */44void initList(Node **pNode)45 {46 *pNode=NULL;47 printf("initList函数执⾏,初始化成功\n");48 }4950/* 2.创建线性表,此函数输⼊负数终⽌读取数据*/51 Node *creatList(Node *pHead)52 {53 Node *p1,*p2;54 p1=p2=(Node *)malloc(sizeof(Node));55if(p1 == NULL || p2 ==NULL)57 printf("内存分配失败\n");58 exit(0);59 }60 memset(p1,0,sizeof(Node));6162 scanf("%d",&p1->element);63 p1->next=NULL;6465while(p1->element >0) //输⼊的值⼤于0则继续,否则停⽌66 {67if(pHead == NULL)//空表,接⼊表头68 {69 pHead=p1;70 }71else72 {73 p2->next=p1;74 }7576 p2=p1;77 p1=(Node *)malloc(sizeof(Node));7879if(p1==NULL||p2==NULL)80 {81 printf("内存分配失败\n");82 exit(0);83 }84 memset(p1,0,sizeof(Node));85 scanf("%d",&p1->element);86 p1->next=NULL;87 }88 printf("CreatList函数执⾏,链表创建成功\n");89return pHead;90 }9192/* 3.打印链表,链表的遍历*/93void printList(Node *pHead)94 {95if(NULL==pHead)96 {97 printf("PrintList函数执⾏,链表为空\n");98 }99else100 {101while(NULL!=pHead)102 {103 printf("%d\n",pHead->element);104 pHead=pHead->next;105 }106 }107108 }109110111/* 4.清除线性表L中的所有元素,即释放单链表L中所有的结点,使之成为⼀个空表 */ 112void clearList(Node *pHead)113 {114 Node *pNext;115116if(pHead==NULL)117 {118 printf("clearList函数执⾏,链表为空\n");119return;120 }121while(pHead->next!=NULL)122 {123 pNext=pHead->next;124free(pHead);125 pHead=pNext;126 }127 printf("clearList函数执⾏,链表已经清除!\n");128129 }130131/* 5.返回链表的长度*/132int sizeList(Node *pHead)133 {134int size=0;135136while(pHead!=NULL)137 {138 size++;139 pHead=pHead->next;141 printf("sizelist函数执⾏,链表长度为%d\n",size);142return size;143 }144145/* 6.检查单链表是否为空,若为空则返回1,否则返回0 */146int isEmptyList(Node *pHead)147 {148if(pHead==NULL)149 {150 printf("isEmptylist函数执⾏,链表为空!\n");151return1;152 }153154else155 printf("isEmptylist函数执⾏,链表⾮空!\n");156return0;157158 }159160/* 7.返回链表中第post节点的数据,若post超出范围,则停⽌程序运⾏*/161int getElement(Node *pHead,int pos)162 {163int i=0;164if(pos<1)165 {166 printf("getElement函数执⾏,pos值⾮法!");167return0;168 }169if(pHead==NULL)170 {171 printf("getElement函数执⾏,链表为空!");172 }173174while (pHead!=NULL)175 {176 ++i;177if(i==pos)178 {179break;180 }181 pHead=pHead->next;182 }183if(i<pos)184 {185 printf("getElement函数执⾏,pos值超出链表长度\n");186return0;187 }188 printf("getElement函数执⾏,位置%d中的元素为%d\n",pos,pHead->element);189190return1;191 }192193//8.从单⼀链表中查找具有给定值x的第⼀个元素,若查找成功后,返回该节点data域的存储位置,否则返回NULL 194 elemType *getElemAddr(Node *pHead,elemType x)195 {196if(NULL==pHead)197 {198 printf("getEleAddr函数执⾏,链表为空");199return NULL;200 }201if(x<0)202 {203 printf("getEleAddr函数执⾏,给定值x不合法\n");204return NULL;205 }206while((pHead->element!=x)&&(NULL!=pHead->next))//判断链表是否为空,并且是否存在所查找的元素207 {208 pHead=pHead->next;209 }210if(pHead->element!=x)211 {212 printf("getElemAddr函数执⾏,在链表中没有找到x值\n");213return NULL;214 }215else216 {217 printf("getElemAddr函数执⾏,元素%d的地址为0x%x\n",x,&(pHead->element));218 }219return &(pHead->element);220221 }222223224/*9.修改链表中第pos个点X的值,如果修改成功,则返回1,否则返回0*/225int modifyElem(Node *pNode,int pos,elemType x)226 {227 Node *pHead;228 pHead=pNode;229int i=0;230if(NULL==pHead)231 {232 printf("modifyElem函数执⾏,链表为空\n");233return0;234 }235236if(pos<1)237 {238 printf("modifyElem函数执⾏,pos值⾮法\n");239return0;240 }241242while(pHead!= NULL)243 {244 ++i;245if(i==pos)246 {247break;248 }249 pHead=pHead->next;250 }251252if(i<pos)253 {254 printf("modifyElem函数执⾏,pos值超出链表长度\n");255return0;256 }257 pNode=pHead;258 pNode->element=x;259 printf("modifyElem函数执⾏,修改第%d点的元素为%d\n",pos,x);260261return1;262263 }264265/* 10.向单链表的表头插⼊⼀个元素 */266int insertHeadList(Node **pNode,elemType insertElem)267 {268 Node *pInsert;269 pInsert=(Node *)malloc(sizeof(Node));270if(pInsert==NULL) exit(1);271 memset(pInsert,0,sizeof(Node));272 pInsert->element=insertElem;273 pInsert->next=*pNode;274 *pNode=pInsert;275 printf("insertHeadList函数执⾏,向表头插⼊元素%d成功\n",insertElem);276return1;277 }278279/* 11.向单链表的末尾添加⼀个元素 */280int insertLastList(Node *pNode,elemType insertElem)281 {282 Node *pInsert;283 Node *pHead;284 Node *pTmp;285286 pHead=pNode;287 pTmp=pHead;288 pInsert=(Node *)malloc(sizeof(Node));289if(pInsert==NULL) exit(1);290 memset(pInsert,0,sizeof(Node));291 pInsert->element=insertElem;292 pInsert->next=NULL;293while(pHead->next!=NULL)294 {295 pHead=pHead->next;296 }297 pHead->next=pInsert;298 printf("insertLastList函数执⾏,向表尾插⼊元素%d成功!\n",insertElem);299return1;300 }301302/* 12.向单链表中第pos个结点位置插⼊元素为x的结点,若插⼊成功返回1,否则返回0*/ 303int isAddPos(Node *pNode,int pos,elemType x)304 {305 Node *pHead;306 pHead=pNode;307 Node *pTmp;308int i=0;309310if(NULL==pHead)311 {312 printf("AddPos函数执⾏,链表为空\n");313return0;314 }315316if(pos<1)317 {318 printf("AddPos函数执⾏,pos值⾮法\n");319return0;320 }321322while(pHead!=NULL)323 {324 ++i;325if(i==pos)326break;327 pHead=pHead->next;328 }329330if(i<pos)331 {332 printf("AddPos函数执⾏,pos值超出链表长度\n");333return0;334 }335336 pTmp=(Node *)malloc(sizeof(Node));337if(pTmp==NULL) exit(1);338 memset(pTmp,0,sizeof(Node));339 pTmp->next=pHead->next;340 pHead->next=pTmp;341 pTmp->element=x;342343 printf("AddPos函数执⾏成功,向节点%d后插⼊数值%d\n",pos,x); 344return1;345 }346347/* 13.向有序单链表中插⼊元素x结点,使得插⼊后仍然有序 */348int OrrderList(Node *pNode,elemType x)349 {350//注意如果此数值要排到⾏尾要修改本代码351 Node *pHead;352 pHead=pNode;353 Node *pTmp;354355if(NULL==pHead)356 {357 printf("OrrderList函数执⾏,链表为空\n");358return0;359 }360361if(x<1)362 {363 printf("OrrderList函数执⾏,x值⾮法\n");364return0;365 }366367while(pHead!=NULL)368 {369if((pHead->element)>=x)370break;371 pHead=pHead->next;372 }373374375if(pHead==NULL)376 {377 printf("OrrderList函数查找完毕,该函数中没有该值\n");378return0;379 }380381382 pTmp=(Node *)malloc(sizeof(Node));383if(pTmp==NULL) exit(1);384 memset(pTmp,0,sizeof(Node));385 pTmp->next=pHead->next;386 pHead->next=pTmp;387 pTmp->element=x;388389 printf("OrrderList函数成功插⼊数值%d\n",x);390return1;391 }392393/*14.从单链表中删除表头结点,并把该结点的值返回,若删除失败则停⽌程序运⾏*/ 394int DelHeadList(Node **pList)395 {396 Node *pHead;397 pHead=*pList;398if(pHead!=NULL)399 printf("DelHeadList函数执⾏,函数⾸元素为%d删除成功\n",pHead->element); 400else401 {402 printf("DelHeadList函数执⾏,链表为空!");403return0;404 }405 *pList=pHead->next;406return1;407 }408409/* 15.从单链表中删除表尾结点并返回它的值,若删除失败则停⽌程序运⾏ */410int DelLastList(Node *pNode)411 {412 Node *pHead;413 Node *pTmp;414415 pHead=pNode;416while(pHead->next!=NULL)417 {418 pTmp=pHead;419 pHead=pHead->next;420 }421 printf("链表尾删除元素%d成功!\n",pHead->element);422free(pHead);423 pTmp->next=NULL;424return1;425 }426427/* 16.从单链表中删除第pos个结点并返回它的值,若删除失败则停⽌程序运⾏ */ 428int DelPos(Node *pNode,int pos)429 {430 Node *pHead;431 pHead=pNode;432 Node *pTmp;433434int i=0;435436if(NULL==pHead)437 {438 printf("DelPos函数执⾏,链表为空\n");439return0;440 }441442if(pos<1)443 {444 printf("DelPos函数执⾏,pos值⾮法\n");445return0;446 }447448while(pHead!=NULL)449 {450 ++i;451if(i==pos)452break;453 pTmp=pHead;454 pHead=pHead->next;455 }456457if(i<pos)458 {459 printf("DelPos函数执⾏,pos值超出链表长度\n");460return0;461 }462 printf("DelPos函数执⾏成功,节点%d删除数值%d\n",pos,pHead->element); 463 pTmp->next=pHead->next;464free(pHead);465return1;466 }467468/* 17.从单链表中删除值为x的第⼀个结点,若删除成功则返回1,否则返回0 */469int Delx(Node **pNode,int x)470 {471 Node *pHead;472 Node *pTmp;473 pHead=*pNode;474int i=0;475476if(NULL==pHead)477 {478 printf("Delx函数执⾏,链表为空");479return0;480 }481if(x<0)482 {483 printf("Delx函数执⾏,给定值x不合法\n");484return0;485 }486while((pHead->element!=x)&&(NULL!=pHead->next))//判断链表是否为空,并且是否存在所查找的元素487 {488 ++i;489 pTmp=pHead;490 pHead=pHead->next;491 }492if(pHead->element!=x)493 {494 printf("Delx函数执⾏,在链表中没有找到x值\n");495return0;496 }497if((i==0)&&(NULL!=pHead->next))498 {499 printf("Delx函数执⾏,在链表⾸部找到此元素,此元素已经被删除\n");500 *pNode=pHead->next;501free(pHead);502return1;503 }504 printf("Delx函数执⾏,⾸个为%d元素被删除\n",x);505 pTmp->next=pHead->next;506free(pHead);507return1;508 }509510/* 18.交换2个元素的位置 */511int exchange2pos(Node *pNode,int pos1,int pos2)512 {513 Node *pHead;514int *pTmp;515int *pInsert;516int a;517int i=0;518519if(pos1<1||pos2<1)520 {521 printf("DelPos函数执⾏,pos值⾮法\n");522return0;523 }524525 pHead=pNode;526while(pHead!=NULL)527 {528 ++i;529if(i==pos1)530break;531 pHead=pHead->next;532 }533534if(i<pos1)535 {536 printf("DelPos函数执⾏,pos1值超出链表长度\n");537return0;538 }539540 pTmp=&(pHead->element);541 i=0;542 pHead=pNode;543while(pHead!=NULL)544 {545 ++i;546if(i==pos2)547break;548 pHead=pHead->next;549 }550551if(i<pos2)552 {553 printf("DelPos函数执⾏,pos2值超出链表长度\n");554return0;555 }556557 pInsert=&(pHead->element);558 a=*pTmp;559 *pTmp=*pInsert;560 *pInsert=a;561562 printf("DelPos函数执⾏,交换第%d个和第%d个pos点的值\n",pos1,pos2); 563return1;564 }565566int swap(int *p1,int *p2)567 {568int a;569if(*p1>*p2)570 {571 a=*p1;572 *p1=*p2;573 *p2=a;574 }575return0;576 }577578/* 19.将线性表进⾏冒泡排序 */579int Arrange(Node *pNode)580 {581 Node *pHead;582 pHead=pNode;583584int a=0,i,j;585586if(NULL==pHead)587 {588 printf("Arrange函数执⾏,链表为空\n");589return0;590 }591592while(pHead!=NULL)593 {594 ++a;595 pHead=pHead->next;596 }597598 pHead=pNode;599for(i=0;i<a-1;i++)600 {601for(j=1;j<a-i;j++)602 {603 swap(&(pHead->element),&(pHead->next->element));604 pHead=pHead->next;605 }606 pHead=pNode;607 }608 printf("Arrange函数执⾏,链表排序完毕!\n");609return0;610 }611612int main()613 {614 Node *pList=NULL;615int length=0;616617 elemType posElem;618619 initList(&pList);620 printList(pList);621622 pList=creatList(pList);623 printList(pList);624625 sizeList(pList);626 printList(pList);627628 isEmptyList(pList);629630631 posElem=getElement(pList,3);632 printList(pList);633634 getElemAddr(pList,5);635636 modifyElem(pList,4,1);637 printList(pList);638639 insertHeadList(&pList,5);640 printList(pList);641642 insertLastList(pList,10);643 printList(pList);644645 isAddPos(pList,4,5); 646 printList(pList);647648 OrrderList(pList,6);649 printList(pList);650651 DelHeadList(&pList); 652 printList(pList);653654 DelLastList(pList);655 printList(pList);656657 DelPos(pList,5);658 printList(pList);659660 Delx(&pList,5);661 printList(pList);662663 exchange2pos(pList,2,5); 664 printList(pList);665666 Arrange(pList);667 printList(pList);668669 clearList(pList);670return0;671 }。
转载--C语言中的__FILE__、__LINE__和__func__
转载--C语⾔中的__FILE__、__LINE__和__func__作者:链接:原链接:C语⾔中的__FILE__⽤以指⽰本⾏语句所在源⽂件的⽂件名,举例如下(test.c):1. #include <stdio.h>2. int main()3. {4. printf("%s\n",__FILE__);5. }在gcc编译⽣成a.out,执⾏后输出结果为:test.c在windows的vc6.0下编译执⾏结果为:c:\documents and settings\administrator\桌⾯\test.c----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------C语⾔中的__LINE__⽤以指⽰本⾏语句在源⽂件中的位置信息,举例如下:1. #include <stdio.h>2.3.4.5. main()6. {7. printf("%d\n",__LINE__);8. printf("%d\n",__LINE__);9. printf("%d\n",__LINE__);10. };该程序在linux⽤gcc编译,在windows的vc6.0下编译都可以通过,执⾏结果都为:789还可以通过语句#line来重新设定__LINE__的值,举例如下:1. #include <stdio.h>2.3.4. #line 200 //指定下⼀⾏的__LINE__为2005. main()6. {7. printf("%d\n",__LINE__);8. printf("%d\n",__LINE__);9. printf("%d\n",__LINE__);10. };编译执⾏后输出结果为:202203204-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------另外gcc还⽀持__func__,它指⽰所在的函数,但是这个关键字不被windows下的vc6.0⽀持,举例如下:1. #include <stdio.h>2. void main()3. {4. printf("this is print by function %s\n",__func__);5. }其编译后输出结果为this is print by function main注意 “#line”、 “__LINE__”、 “__FILE__" 及 “__func__" 都是⼤⼩写敏感的。
转载C++输入与输出—cout和cin的用法
转载C++输⼊与输出—cout和cin的⽤法转载⽹址:输⼊和输出并不是C++语⾔中的正式组成成分。C和C++本⾝都没有为输⼊和输出提供专门的语句结构。输⼊输出不是由C++本⾝定义的,⽽是在编译系统提供的I/O库中定义的。C++的输出和输⼊是⽤“流”(stream)的⽅式实现的。图3.2和图3.3表⽰C++通过流进⾏输⼊输出的过程。有关流对象cin、cout和流运算符的定义等信息是存放在C++的输⼊输出流库中的,因此如果在程序中使⽤cin、cout和流运算符,就必须使⽤预处理命令把头⽂件stream包含到本⽂件中:#include <iostream>尽管cin和cout不是C++本⾝提供的语句,但是在不致混淆的情况下,为了叙述⽅便,常常把由cin和流提取运算符“>>”实现输⼊的语句称为输⼊语句或cin语句,把由cout和流插⼊运算符“<<”实现输出的语句称为输出语句或cout语句。根据C++的语法,凡是能实现某种操作⽽且最后以分号结束的都是语句。⼀、输⼊流与输出流的基本操作cout语句的⼀般格式为:cout<<表达式1<<表达式2<<……<<表达式n;cin语句的⼀般格式为:cin>>变量1>>变量2>>……>>变量n;在定义流对象时,系统会在内存中开辟⼀段缓冲区,⽤来暂存输⼊输出流的数据。在执⾏cout语句时,先把插⼊的数据顺序存放在输出缓冲区中,直到输出缓冲区满或遇到cout语句中的endl(或'\n',ends,flush)为⽌,此时将缓冲区中已有的数据⼀起输出,并清空缓冲区。输出流中的数据在系统默认的设备(⼀般为显⽰器)输出。⼀个cout语句可以分写成若⼲⾏。如cout<<"This is a simple C++ program."<<endl;可以写成cout<<"This is " //注意⾏末尾⽆分号<<"a C++ "<<"program."<<endl; //语句最后有分号也可写成多个cout语句,即cout<<"This is "; //语句末尾有分号cout <<"a C++ ";cout <<"program.";cout<<endl;以上3种情况的输出均为This is a simple C++ program.注意不能⽤⼀个插⼊运算符“<<”插⼊多个输出项,如:cout<<a,b,c; //错误,不能⼀次插⼊多项cout<<a+b+c; //正确,这是⼀个表达式,作为⼀项在⽤cout输出时,⽤户不必通知计算机按何种类型输出,系统会⾃动判别输出数据的类型,使输出的数据按相应的类型输出。如已定义a为int型,b 为float型,c为char型,则cout<<a<<' '<<b<<' '<<c<<endl;会以下⾯的形式输出:4 345.789 a与cout类似,⼀个cin语句可以分写成若⼲⾏。如cin>>a>>b>>c>>d;可以写成cin>>a //注意⾏末尾⽆分号>>b //这样写可能看起来清晰些>>c>>d;也可以写成cin>>a;cin>>b;cin>>c;cin>>d;以上3种情况均可以从键盘输⼊: 1 2 3 4 ↙也可以分多⾏输⼊数据:1↙2 3↙4↙在⽤cin输⼊时,系统也会根据变量的类型从输⼊流中提取相应长度的字节。如有char c1,c2;int a;float b;cin>>c1>>c2>>a>>b;如果输⼊1234 56.78↙注意: 34后⾯应该有空格以便和56.78分隔开。也可以按下⾯格式输⼊:1 2 34 56.78↙ (在1和2之间有空格)不能⽤cin语句把空格字符和回车换⾏符作为字符输⼊给字符变量,它们将被跳过。如果想将空格字符或回车换⾏符(或任何其他键盘上的字符)输⼊给字符变量,可以⽤3.4.3节介绍的getchar函数。在组织输⼊流数据时,要仔细分析cin语句中变量的类型,按照相应的格式输⼊,否则容易出错。⼆、在输⼊流与输出流中使⽤控制符上⾯介绍的是使⽤cout和cin时的默认格式。但有时⼈们在输⼊输出时有⼀些特殊的要求,如在输出实数时规定字段宽度,只保留两位⼩数,数据向左或向右对齐等。C++提供了在输⼊输出流中使⽤的控制符(有的书中称为操纵符)。需要注意的是: 如果使⽤了控制符,在程序单位的开头除了要加iostream头⽂件外,还要加iomanip头⽂件。举例: 输出双精度数。double a=123.456789012345;对a赋初值(1) cout<<a;输出: 123.456(2) cout<<setprecision(9)<<a;输出: 123.456789(3) cout<<setprecision(6);恢复默认格式(精度为6)(4) cout<< setiosflags(ios∷fixed);输出: 123.456789(5) cout<<setiosflags(ios∷fixed)<<setprecision(8)<<a;输出: 123.45678901(6) cout<<setiosflags(ios∷scientific)<<a;输出: 1.234568e+02(7) cout<<setiosflags(ios∷scientific)<<setprecision(4)<<a; 输出: 1.2346e02下⾯是整数输出的例⼦:int b=123456;对b赋初值(1) cout<<b;输出: 123456(2) cout<<hex<<b; 输出: 1e240(3) cout<<setiosflags(ios∷uppercase)<<b;输出: 1E240(4) cout<<setw(10)<<b<<','<<b; 输出: 123456,123456(5) cout<<setfill('*')<<setw(10)<<b;输出: **** 123456(6) cout<<setiosflags(ios∷showpos)<<b;输出: +123456如果在多个cout语句中使⽤相同的setw(n),并使⽤setiosflags(ios∷right),可以实现各⾏数据右对齐,如果指定相同的精度,可以实现上下⼩数点对齐。例3.1 各⾏⼩数点对齐。#include <iostream>#include <iomanip>using namespace std;int main( ){double a=123.456,b=3.14159,c=-3214.67;cout<<setiosflags(ios∷fixed)<<setiosflags(ios∷right)<<setprecision(2);cout<<setw(10)<<a<<endl;cout<<setw(10)<<b<<endl;cout<<setw(10)<<c<<endl;return0;}输出如下:123.46 (字段宽度为10,右对齐,取两位⼩数)3.14-3214.67先统⼀设置定点形式输出、取两位⼩数、右对齐。这些设置对其后的输出均有效(除⾮重新设置),⽽setw只对其后⼀个输出项有效,因此必须在输出a,b,c之前都要写setw(10)。学C++的时候,这⼏个输⼊函数弄的有点迷糊;这⾥做个⼩结,为了⾃⼰复习,也希望对后来者能有所帮助,如果有差错的地⽅还请各位多多指教(本⽂所有程序均通过VC 6.0运⾏)转载请保留作者信息;1、cin1、cin.get()2、cin.getline()3、getline()4、gets()5、getchar()1、cin>>⽤法1:最基本,也是最常⽤的⽤法,输⼊⼀个数字:#include <iostream>using namespace std;main (){int a,b;cin>>a>>b;cout<<a+b<<endl;}输⼊:2[回车]3[回车]输出:5⽤法2:接受⼀个字符串,遇“空格”、“TAB”、“回车”都结束#include <iostream>using namespace std;main (){char a[20];cin>>a;cout<<a<<endl;}输⼊:jkljkljkl输出:jkljkljkl输⼊:jkljkl jkljkl //遇空格结束输出:jkljkl2、cin.get()⽤法1: cin.get(字符变量名)可以⽤来接收字符#include <iostream>using namespace std;main (){char ch;ch=cin.get(); //或者cin.get(ch);cout<<ch<<endl;}输⼊:jljkljkl输出:j⽤法2:cin.get(字符数组名,接收字符数⽬)⽤来接收⼀⾏字符串,可以接收空格#include <iostream>using namespace std;main (){char a[20];cin.get(a,20);cout<<a<<endl;}输⼊:jkl jkl jkl输出:jkl jkl jkl输⼊:abcdeabcdeabcdeabcdeabcde (输⼊25个字符)输出:abcdeabcdeabcdeabcd (接收19个字符+1个'\0')⽤法3:cin.get(⽆参数)没有参数主要是⽤于舍弃输⼊流中的不需要的字符,或者舍弃回车,弥补cin.get(字符数组名,接收字符数⽬)的不⾜.这个我还不知道怎么⽤,知道的前辈请赐教;3、cin.getline() // 接受⼀个字符串,可以接收空格并输出#include <iostream>using namespace std;main (){char m[20];cin.getline(m,5);cout<<m<<endl;}输⼊:jkljkljkl输出:jklj接受5个字符到m中,其中最后⼀个为'\0',所以只看到4个字符输出;如果把5改成20:输⼊:jkljkljkl输出:jkljkljkl输⼊:jklf fjlsjf fjsdklf输出:jklf fjlsjf fjsdklf//延伸://cin.getline()实际上有三个参数,cin.getline(接受字符串的看哦那间m,接受个数5,结束字符)//当第三个参数省略时,系统默认为'\0'//如果将例⼦中cin.getline()改为cin.getline(m,5,'a');当输⼊jlkjkljkl时输出jklj,输⼊jkaljkljkl时,输出jk当⽤在多维数组中的时候,也可以⽤cin.getline(m[i],20)之类的⽤法:#include<iostream>#include<string>using namespace std;main (){char m[3][20];for(int i=0;i<3;i++){cout<<"\n请输⼊第"<<i+1<<"个字符串:"<<endl;cin.getline(m[i],20);}cout<<endl;for(int j=0;j<3;j++)cout<<"输出m["<<j<<"]的值:"<<m[j]<<endl;}请输⼊第1个字符串:kskr1请输⼊第2个字符串:kskr2请输⼊第3个字符串:kskr3输出m[0]的值:kskr1输出m[1]的值:kskr2输出m[2]的值:kskr34、getline() // 接受⼀个字符串,可以接收空格并输出,需包含“#include<string>”#include<iostream>#include<string>using namespace std;main (){string str;getline(cin,str);cout<<str<<endl;}输⼊:jkljkljkl输出:jkljkljkl输⼊:jkl jfksldfj jklsjfl输出:jkl jfksldfj jklsjfl和cin.getline()类似,但是cin.getline()属于istream流,⽽getline()属于string流,是不⼀样的两个函数5、gets() // 接受⼀个字符串,可以接收空格并输出,需包含“#include<string>”#include<iostream>#include<string>using namespace std;main (){char m[20];gets(m); //不能写成m=gets();cout<<m<<endl;}输⼊:jkljkljkl输出:jkljkljkl输⼊:jkl jkl jkl输出:jkl jkl jkl类似cin.getline()⾥⾯的⼀个例⼦,gets()同样可以⽤在多维数组⾥⾯:#include<iostream>#include<string>using namespace std;main (){char m[3][20];for(int i=0;i<3;i++){cout<<"\n请输⼊第"<<i+1<<"个字符串:"<<endl;gets(m[i]);}cout<<endl;for(int j=0;j<3;j++)cout<<"输出m["<<j<<"]的值:"<<m[j]<<endl;}请输⼊第1个字符串:kskr1请输⼊第2个字符串:kskr2请输⼊第3个字符串:kskr3输出m[0]的值:kskr1输出m[1]的值:kskr2输出m[2]的值:kskr3⾃我感觉gets()和cin.getline()的⽤法很类似,只不过cin.getline()多⼀个参数罢了;这⾥顺带说明⼀下,对于本⽂中的这个kskr1,kskr2,kskr3的例⼦,对于cin>>也可以适⽤,原因是这⾥输⼊的没有空格,如果输⼊了空格,⽐如“ks kr jkl[回车]”那么cin就会已经接收到3个字符串,“ks,kr,jkl”;再如“kskr 1[回车]kskr 2[回车]”,那么则接收“kskr,1,kskr”;这不是我们所要的结果!⽽cin.getline()和gets()因为可以接收空格,所以不会产⽣这个错误;6、getchar() //接受⼀个字符,需包含“#include<string>”#include<iostream>#include<string>using namespace std;main (){char ch;ch=getchar(); //不能写成getchar(ch);cout<<ch<<endl;}输⼊:jkljkljkl输出:j。
2D-FFT及IFFT(C语言实现(转载)
2D-FFT及IFFT(C语言实现(转载)FFT与IFFT有如下关系:相应的2D-FFT与2D-IFFT的关系如下:所以可以利用一个FFT核心函数实现2D-FFT与2D-IFFT。
代码如下:#include <stdio.h>#include <stdlib.h>#include <math.h>#define intsize sizeof(int)#define complexsize sizeof(complex)#define PI 3.1415926int *a,*b;int nLen,init_nLen,mLen,init_mLen,N,M;FILE *dataFile;typedef struct{float real;float image;}complex;complex *A,*A_In,*W;complex Add(complex, complex);complex Sub(complex, complex);complex Mul(complex, complex);int calculate_M(int);void reverse(int,int);void readData();void fft(int,int);void Ifft();void printResult_fft();void printResult_Ifft();int main(){int i,j;readData();A = (complex *)malloc(complexsize*nLen);reverse(nLen,N);for(i=0; i<mLen; i++){for(j=0; j<nLen; j++){A[j].real = A_In[i*nLen+b[j]].real;A[j].image = A_In[i*nLen+b[j]].image;}fft(nLen,N);for(j=0; j<nLen; j++){A_In[i*nLen+j].real = A[j].real;A_In[i*nLen+j].image = A[j].image;}}free(a);free(b);free(A);A = (complex *)malloc(complexsize*mLen); reverse(mLen,M);for(i=0; i<nLen; i++){for(j=0; j<mLen; j++){A[j].real = A_In[b[j]*nLen+i].real;A[j].image = A_In[b[j]*nLen+i].image;}fft(mLen,M);for(j=0; j<mLen; j++){A_In[j*nLen+i].real = A[j].real;A_In[j*nLen+i].image = A[j].image;}}free(A);printResult_fft();Ifft();printResult_Ifft();return 0;}void readData(){int i,j;dataFile = fopen("dataIn.txt","r");fscanf(dataFile,"%d %d",&init_mLen,&init_nLen);M = calculate_M(init_mLen);N = calculate_M(init_nLen);nLen = (int)pow(2,N);mLen = (int)pow(2,M);A_In = (complex *)malloc(complexsize*nLen*mLen);for(i=0; i<init_mLen; i++){for(j=0; j<init_nLen; j++){fscanf(dataFile,"%f",&A_In[i*nLen+j].real);A_In[i*nLen+j].image = 0.0;}}fclose(dataFile);for(i=0; i<mLen; i++){for(j=init_nLen; j<nLen; j++){A_In[i*nLen+j].real = 0.0;A_In[i*nLen+j].image = 0.0;}}for(i=init_mLen; i<mLen; i++){for(j=0; j<init_nLen; j++){A_In[i*nLen+j].real = 0.0;A_In[i*nLen+j].image = 0.0;}}printf("Reading initial datas:\n");for(i=0; i<init_mLen; i++){for(j=0; j<init_nLen; j++){if(A_In[i*nLen+j].image < 0){printf("%f%fi\t",A_In[i*nLen+j].real,A_In[i*nLen+j].image);}else{printf("%f+%fi\t",A_In[i*nLen+j].real,A_In[i*nLen+j].image);}}printf("\n");}printf("\n");printf("Reading formal datas:\n");for(i=0; i<mLen; i++){for(j=0; j<nLen; j++){if(A_In[i*nLen+j].image < 0){printf("%f%fi\t",A_In[i*nLen+j].real,A_In[i*nLen+j].image);}else{printf("%f+%fi\t",A_In[i*nLen+j].real,A_In[i*nLen+j].image);}}printf("\n");}}void fft(int fft_nLen, int fft_M){int i;int lev,dist,p,t;complex B;W = (complex *)malloc(complexsize*fft_nLen/2);for(lev=1; lev<=fft_M; lev++){dist = (int)pow(2,lev-1);for(t=0; t<dist; t++){p = t*(int)pow(2,fft_M-lev);W[p].real = (float)cos(2*PI*p/fft_nLen);W[p].image =(float)(-1*sin(2*PI*p/fft_nLen));for(i=t; i<fft_nLen; i=i+(int)pow(2,lev)){B = Add(A[i],Mul(A[i+dist],W[p]));A[i+dist] = Sub(A[i],Mul(A[i+dist],W[p]));A[i].real = B.real;A[i].image = B.image;}}}free(W);}void printResult_fft(){int i,j;printf("Output FFT results:\n");for(i=0; i<mLen; i++){for(j=0; j<nLen; j++){if(A_In[i*nLen+j].image < 0){printf("%f%fi\t",A_In[i*nLen+j].real,A_In[i*nLen+j].image);}else{printf("%f+%fi\t",A_In[i*nLen+j].real,A_In[i*nLen+j].image);}}printf("\n");}}void printResult_Ifft(){int i,j;printf("Output IFFT results:\n");for(i=0; i<mLen; i++){for(j=0; j<nLen; j++){if(A_In[i*nLen+j].image < 0){printf("%f%fi\t",A_In[i*nLen+j].real,A_In[i*nLen+j].image);}else{printf("%f+%fi\t",A_In[i*nLen+j].real,A_In[i*nLen+j].image);}}printf("\n");}free(A_In);}int calculate_M(int len){int i;int k;i = 0;k = 1;while(k < len){k = k*2;i++;}return i;}void reverse(int len, int M){int i,j;a = (int *)malloc(intsize*M);b = (int *)malloc(intsize*len);for(i=0; i<M; i++){a[i] = 0;}b[0] = 0;for(i=1; i<len; i++){j = 0;while(a[j] != 0){a[j] = 0;j++;}a[j] = 1;b[i] = 0;for(j=0; j<M; j++){b[i] = b[i]+a[j]*(int)pow(2,M-1-j);}}}complex Add(complex c1, complex c2){complex c;c.real = c1.real+c2.real;c.image = c1.image+c2.image;return c;}complex Sub(complex c1, complex c2){complex c;c.real = c1.real-c2.real;c.image = c1.image-c2.image;return c;}complex Mul(complex c1, complex c2){complex c;c.real = c1.real*c2.real-c1.image*c2.image;c.image = c1.real*c2.image+c2.real*c1.image;return c;}void Ifft(){int i,j;for(i=0; i<mLen; i++){for(j=0; j<nLen; j++){A_In[i*nLen+j].image =-A_In[i*nLen+j].image;}}A = (complex *)malloc(complexsize*nLen); reverse(nLen,N);for(i=0; i<mLen; i++){for(j=0; j<nLen; j++){A[j].real = A_In[i*nLen+b[j]].real;A[j].image = A_In[i*nLen+b[j]].image;}fft(nLen,N);for(j=0; j<nLen; j++){A_In[i*nLen+j].real = A[j].real/nLen;A_In[i*nLen+j].image = A[j].image/nLen;}}free(A);free(a);free(b);A = (complex *)malloc(complexsize*mLen);reverse(mLen,M);for(i=0; i<nLen; i++){for(j=0; j<mLen; j++){A[j].real = A_In[b[j]*nLen+i].real;A[j].image = A_In[b[j]*nLen+i].image;}fft(mLen,M);for(j=0; j<mLen; j++){A_In[j*nLen+i].real = A[j].real/mLen;A_In[j*nLen+i].image = A[j].image/mLen;}}free(A);free(a);free(b);}测试数据及结果如下:数据输入文件data_In.txt的内容如下:3 31 2 53 2 55 6 4测试结果如下:Reading initial datas:1.000000+0.000000i2.000000+0.000000i 5.000000+0.000000i3.000000+0.000000i 2.000000+0.000000i 5.000000+0.000000i5.000000+0.000000i6.000000+0.000000i 4.000000+0.000000iReading formal datas:1.000000+0.000000i2.000000+0.000000i 5.000000+0.000000i 0.000000+0.000000i3.000000+0.000000i 2.000000+0.000000i 5.000000+0.000000i 0.000000+0.000000i 5.000000+0.000000i 6.000000+0.000000i4.000000+0.000000i 0.000000+0.000000i 0.000000+0.000000i 0.000000+0.000000i 0.000000+0.000000i 0.000000+0.000000i Output FFT results:33.000000+0.000000i -5.000000-10.000000i 13.000000+0.000000i -5.000000+10.000000i -7.000000-10.000000i -7.000000+6.000000i 1.000000-6.000000i -3.000000-2.000000i 13.000000+0.000000i -1.000000-6.000000i 1.000000+0.000000i -1.000000+6.000000i -7.000000+10.000000i -3.000000+2.000000i 1.000000+6.000000i -7.000000-6.000000i Output IFFT results:1.000000+0.000000i2.000000+0.000000i 5.000000+0.000000i 0.000000-0.000000i3.000000+0.000000i 2.000000+0.000000i 5.000000+0.000000i 0.000000-0.000000i 5.000000+0.000000i 6.000000+0.000000i4.000000+0.000000i -0.000000-0.000000i 0.000000-0.000000i 0.000000+0.000000i 0.000000-0.000000i -0.000000+0.000000i Press any key to continue。
Objective-C关于静态方法与实例方法的转载
Objective-C关于静态⽅法与实例⽅法的转载objective-c中⾮常重要的语法知识,在此归纳总结⼀下。
类⽅法,也称静态⽅法,指的是⽤static关键字修饰的⽅法。
此⽅法属类本⾝的⽅法,不属于类的某⼀个实例(对象)。
类⽅法中不可直接使⽤实例变量。
其调⽤⽅式有三种:可直接调⽤、类名.⽅法名、对象名.⽅法名。
实例⽅法指的是不⽤static关键字修饰的⽅法。
每个实例对象都有⾃⾝的实例⽅法,互相独⽴,不共享⼀个。
其调⽤⽅式只能是对象名.⽅法名。
⽤修饰符static声明的⽅法为静态⽅法,不⽤修饰符static声明的⽅法为实例⽅法。
不管类⽣成或未⽣成对象,类的静态⽅法都可以被使⽤,使⽤格式为:类名.静态⽅法名。
静态⽅法只能使⽤该静态⽅法所在类的静态数据成员和静态⽅法。
这是因为使⽤静态⽅法时,该静态⽅法所在类可能还没有对象,即使有对象,由于⽤类名.静态⽅法名⽅式调⽤静态⽅法,静态⽅法没有this指针来存放对象的地址,⽆法判定应访问哪个对象的数据成员。
在类创建对象后,实例⽅法才能被使⽤,使⽤格式为:对象名.实例⽅法名。
实例⽅法可以使⽤该⽅法所在类的所有静态成员和实例成员。
何时⽤静态⽅法,何时⽤实例⽅法?先说实例⽅法,当你给⼀个类写⼀个⽅法,如果该⽅法需要访问某个实例的成员变量时,那么就将该⽅法定义成实例⽅法。
⼀类的实例通常有⼀些成员变量,其中含有该实例的状态信息。
⽽该⽅法需要改变这些状态。
那么该⽅法需要声明成实例⽅法。
静态⽅法正好相反,它不需要访问某个实例的成员变量,它不需要去改变某个实例的状态。
我们把该⽅法定义成静态⽅法。
关于静态⽅法和实例⽅法的⼀些误区。
⼀、静态⽅法常驻内存,实例⽅法不是,所以静态⽅法效率⾼但占内存。
事实上,⽅法都是⼀样的,在加载时机和占⽤内存上,静态⽅法和实例⽅法是⼀样的,在类型第⼀次被使⽤时加载。
调⽤的速度基本上没有差别。
⼆、静态⽅法在堆上分配内存,实例⽅法在堆栈上。
事实上所有的⽅法都不可能在堆或者堆栈上分配内存,⽅法作为代码是被加载到特殊的代码内存区域,这个内存区域是不可写的。
转载 国产精品解码器MDAC5
转载国产精品解码器MDAC5原文地址:国产精品解码器MDAC5作者:小白国产解码器MDAC5我最早是在3月份的上海音响展上看到工程样机的。
当时此样机就放在安润的展房里,接一台笔记本电脑开声,3天展会期间过来听的人也不少。
我简单地听了一下,很容易判断,这是一台声音品质很好的解码器,但限于时间和环境,也没有过多细听。
定性地判断一个产品是好、还是不好,对我来说是无须费很多劲、反复听半天的。
之后厂家询问我有什么意见,我只简单地回答了一句:是台好机器,希望早日看到量产上市!于是厂家加紧了量产工作,终于在五一节前夕把它的首批成品搞出来了。
下图是目前在我店里的MDAC5成品样机,我特地拿了一台MDAC2放在它上面,可以直观地比较体积的大小,不难看出,电源分体设计的MDAC5,其体积正好是MDAC2的两倍,也就是说它的主机、电源,都和MDAC2大小完全相同。
当然,颜色完全改了,从MDA2的银白色变为纯黑。
下面是MDAC5解码器的背面。
左边的是分体式的电源,右边的是主机。
图中的MDAC5接着平衡XLR输出。
红色的线缆是厂家提供的电源线,从分体电源连接到主机。
再仔细看下MDAC5的主机,它有一对RCA输出、一对XLR平衡输出、一只同轴形式的数字输出、以及5组跳线(中间部位红色的东西)。
这5组跳线可以用于控制:1)输出电平是固定还是可变;2)相位正反;3)数字滤波模式;4)去加重电路的开关;5)超取样倍数(默认状态是64倍,但可设置为32倍或128倍)。
MDAC的厂家从一开始就对外包装很用心,包括一千多元的MDAC2,其外包装也是非常正规的,毫无国产HI-FI产品包装上常见的"山寨味道"。
这部新出的MDAC5,其外包装也是设计得很用心的,方方正正的纸盒,虽说不上十分漂亮,但扎实、质朴、实用。
这台MDAC5样机已不是全新机,在我之前已经有两位烧友玩过一把。
接下来我稍微说说这台MDAC5在我手中的使用情况。
[转载]c语言实现单片机的tcpip通信
[转载]c语⾔实现单⽚机的tcpip通信repost原⽂地址:c语⾔实现单⽚机的tcp/ip通信作者:谢绝关注#include "system.h"#include "tcpip.h"#include "drivers.h"// 定义应⽤:1 表⽰开启功能,0 表⽰关闭功能#define cTCP_RS232 1 // TCP <-> RS232 的应⽤,只⽤于服务模式#define cTCP_ADAC 1 // TCP <-> Audio, 主要⽤于服务,也可以⽤于客户。
要求⾼带宽: > 912Kbit// 分配本地⽤户⾃定义服务模式应⽤TCP端⼝号,不能与知名端⼝相同!如:23, 80// 注意:对不同的TCP事件使⽤不同的本地端⼝号,有助于快速查找TCP事件⽽不需要判断IP是否相同!// 这样做能使本地快速响应。
#define cTCP_ListenPort_TEST 0x1000 // 4096#if cTCP_RS232 == 1#define cTCP_ListenPort_RS232 0x2000 // 8192#endif#if cTCP_ADAC == 0#define cTCP_ListenPort_ADAC 0x3000 // 12288#endif// 客户应⽤模式的本地TCP端⼝号。
不能与知名端⼝相同!如:23, 80// 注意:对不同的TCP事件使⽤不同的本地端⼝号(包括:本地侦听端⼝),有助于快速查找TCP事件⽽// 不需要判断IP是否相同!这样做能使本地快速响应。
#if (cTCP_ADAC == 1) && (TCP_ACTIVE_OPEN == 1)#define cTCP_ActivePort_ADAC 0x3001 // 12289#endif// 分配系统应⽤临时缓冲区(按 wrod 存储)UINT16 guwAppBuf[cAppSizeMax];//--------------------------------------------------------------------------------------main(){#if TCP_ACTIVE_OPEN == 1UINT16 temp[2];#endif// 1. Hardware initialize: SPCE061ASP_IO_INIT();// 2. Open and Enable Hardware interrupt 2Hz and Clear WatchDog!SP_OpenTime2();// 3. Hardware initialize: RTL8019ASRTL8019AS_RESET();RTL8019AS_INIT();// 4. vIP4 TCP/IP initializemsip_Init();// 5. We listen test portmsip_Listen(cTCP_ListenPort_TEST); // ⽤于侦听来⾃链路测试的TCP包#if cTCP_RS232 == 1SP_UART_INIT(C_UART_Baud_115200); // Hardware initialize: UART of SPCE061Amsip_Listen(cTCP_ListenPort_RS232); // ⽤于侦听来⾃RS232的TCP包#endif#if cTCP_ADAC == 1// SP_ADAC_INIT(cSample_4096); // Open ADAC// SP_ADAC_INIT(cSample_8192); // Open ADAC// SP_ADAC_INIT(cSample_16384); // Open ADAC// SP_ADAC_INIT(cSample_32768); // Open ADAC// SP_CLOSE_FIQ(); // 关闭FIQ中断,同时也禁⽌了ADACmsip_Listen(cTCP_ListenPort_ADAC); // ⽤于侦听来⾃远端的Audio的TCP包#endif#if (cTCP_ADAC == 1) && (TCP_ACTIVE_OPEN == 1)// for test audio, wo active link remote: 192.168.0.60temp[0] = ((192<<8)|168);temp[1] = ((0<<8)|30);msip_Connect(cTCP_ActivePort_ADAC, temp, cTCP_ListenPort_ADAC);#endif// 6. We do TCP/IP Check Looploop:// 接收新的以太包,并处理if ((guwEthLen = ether_Receive()) != 0){switch (cptEthHdrBuf->EthType){case cEthType_Arp:msip_Arp_In();break;case cEthType_Ip:msip_Input();}}// ARP表⽼化处理if (guwMsg_Route & cM_ARP_TIME){msip_Arp_Time();}// TCP事件轮询if (guwMsg_Route & cM_TCP_PERIODIC){msip_Periodic();}goto loop;}// SUB-SUB-SUB-SUB-SUB-SUB-SUB-SUB-SUB-SUB-SUB-SUB-SUB-SUB-SUB-SUB-SUB-SUB-SUB-SUB-SUB//--------------------------------------------------------------------------------------//// |--------------| |-----|----------|------| |------|--------|// |⼯业设备|RS232| <---> |RS232|核⼼嵌⼊板|TCP/IP| <---> |TCP/IP|普通PC机|// |--------------| |-----|----------|------| |------|--------|////-------------------------------------------------------------------------------------void userapp(){switch (gptConn->LocalPort){#if cTCP_RS232 == 1case cTCP_ListenPort_RS232:goto link_rs232;#endif#if cTCP_ADAC == 1 // ADAC ⼯作时:由于双向通讯,所以Listen和Active处理是⼀样的!case cTCP_ListenPort_ADAC:goto link_adac_listen;#endif#if (cTCP_ADAC == 1) && (TCP_ACTIVE_OPEN == 1) // ADAC ⼯作时:由于双向通讯,所以Listen和Active处理是⼀样的!case cTCP_ActivePort_ADAC:goto link_adac_active;#endifcase cTCP_ListenPort_TEST:goto test_net;default:return;}#if cTCP_RS232 == 1link_rs232: // 与RS232透明传输通讯:本系统的⼀个应⽤。
[转载]XModem协议源码-xmodem.c
c = port_inbyte((DLY_1S)<<1);
if (last_error == 0)
{
switch (c)
{
case SOH:
bufsz = 128;
goto start_recv;
return -1;
}
break;
default:
break;
}
}
}
port_outbyte(CAN);
port_outbyte(CAN);
port_outbyte(CAN);
flushinput();
unsigned char packetno = 1;
int i, c, len = 0;
int retry, retrans = MAXRETRANS;
for(;;)
{
for( retry = 0; retry < 16; ++retry)
{
if (trychar)
flushinput();
return -4;
}else{
for (retry = 0; retry < 10; ++retry)
{
port_outbyte(EOT);
c = port_inbyte((DLY_1S)<<1);
if (c == ACK)
if (c < bufsz) xbuff[3+c] = CTRLZ;
}
if (crc)
{
unsigned short ccrc = crc16_ccitt(&xbuff[3], bufsz);
人大复印转载流程
一、引言中国人民大学复印报刊资料(以下简称“人大复印”)是中国最具影响力的学术资料库之一,为学术界提供了丰富的文献资源。
随着学术交流的日益频繁,许多学者和研究人员希望将自己的研究成果在人大复印上转载,以扩大研究成果的影响力。
本文将详细阐述人大复印转载的流程,旨在帮助作者了解和顺利完成转载工作。
二、准备阶段1. 确定转载意向在准备阶段,作者首先需要确定是否希望将自己的研究成果在人大复印上转载。
这需要考虑以下因素:(1)研究成果的学术价值:研究成果是否具有较高的学术价值,是否具有广泛的应用前景。
(2)研究领域的需求:研究领域是否需要相关的研究成果,转载该成果是否有助于推动该领域的发展。
(3)个人发展需求:转载研究成果是否有助于提高个人学术地位和影响力。
2. 撰写投稿材料确定转载意向后,作者需要准备以下材料:(1)论文全文:确保论文内容完整、格式规范。
(2)摘要:撰写简洁明了的摘要,突出论文的核心观点和创新点。
(3)关键词:选择3-5个与论文主题相关且具有检索价值的关键词。
(4)作者简介:包括作者姓名、单位、职称、研究方向等基本信息。
三、投稿阶段1. 选择合适的专辑作者需要根据论文的研究领域和主题,选择合适的专辑进行投稿。
人大复印共设有数百个专辑,涵盖了各个学科领域。
2. 注册账号并登录作者需在人大复印官方网站注册账号,并登录系统进行投稿。
注册过程中,需填写个人信息、研究方向等。
3. 填写投稿信息登录系统后,作者需按照要求填写以下信息:(1)论文题目:确保题目准确、简洁,反映论文主题。
(2)作者信息:包括作者姓名、单位、职称、研究方向等。
(3)专辑选择:根据论文主题选择合适的专辑。
(4)论文摘要:粘贴论文摘要内容。
(5)关键词:输入3-5个关键词。
4. 上传论文全文在填写完投稿信息后,作者需上传论文全文。
上传过程中,确保论文格式符合要求,如Word文档、PDF文档等。
5. 提交投稿完成以上步骤后,作者需仔细检查投稿信息,确认无误后提交投稿。
【转载】C中的access函数
【转载】C中的access函数分类: C/C++int access(const char *filename, int amode);amode参数为0时表⽰检查⽂件的存在性,如果⽂件存在,返回0,不存在,返回-1。
这个函数还可以检查其它⽂件属性:06 检查读写权限04 检查读权限02 检查写权限01 检查执⾏权限00 检查⽂件的存在性⽽这个就算这个⽂件没有读权限,也可以判断这个⽂件存在于否存在返回0,不存在返回-1C函数 函数名: access 功能: 确定⽂件的访问权限 ⽤法: int access(const char *filename, int amode);[编辑本段]access Synopsis #include int _access(const char *path,int mode) ; Description The access function, when used with files, determines whether the specified file exists and can be accessed as specified by the value of mode. When used with directories, _access determines only whether the specified directory exists; since under Windows all directories have read and write access. The mode argument can be one of : 00 Existence only 02 Write permission 04 Read permission 06 Read and write permission Returns Zero if the file has the given mode, -1 if an error occurs. Portability : Windows. Under Unix a similar function exists too. Note that lcc-win32 accepts both _access (Microsoft convention) and access. 程序例:1#include <stdio.h>2 #include <io.h>3 int file_exists(char *filename);4 int main(void)5 {6 printf("Does NOTEXIST.FIL exist: %s\n",7 file_exists("NOTEXISTS.FIL") ? "YES" : "NO");8 return0;9 }10 int file_exists(char *filename)11 {12 return (access(filename, 0) == 0);13 }。
著作权法中关于转载的法定许可
著作权法中关于转载的法定许可作品刊登后,除著作权人声明不得转载、摘编的外,其他报刊可以转载或者作为文摘、资料刊登,但应当按照规定向著作权人支付报酬。
(著作权法第33条第二款)以上是著作权法规定的五种法定许可的一种,即报刊之间的转载、摘编的法定许可。
法定许可是著作权法给予作品使用者的一种特别许可,即可以不经作者或其他著作权人同意而使用其已发表的作品。
依据法定许可而使用他人作品时,应当按照规定,向作者或其他著作权人支付报酬,并应当注明作者姓名、作品名称和出处。
法定许可规定的五种情形:《著作权法》和《信息网络传播权保护条例》对法定许可规定了5+1种情况:1、期刊转载的法定许可、著作权法33条第2款:作品刊登后,除著作权人声明不得转载、摘编的外,其他报刊可以转载或者作为文摘、资料刊登,但应当按照规定向著作权人支付报酬。
2、制作录音制品的法定许可、著作权法40条第三款:录音制作者使用他人已经合法录制为录音制品的音乐作品制作录音制品,可以不经著作权人许可,但应当按照规定支付报酬;著作权人声明不许使用的不得使用。
3、播放作品的法定许可和摆放录音制品的法定许可、著作权法第43条第二款:广播电台、电视台播放他人已发表的作品,可以不经著作权人许可,但应当支付报酬。
第44条:广播电台、电视台播放已经出版的录音制品,可以不经著作权人许可,但应当支付报酬。
当事人另有约定的除外。
4、编写出版教科书的法定许可、著作权法23条第一款:为实施九年制义务教育和国家教育规划而编写出版教科书,除作者事先声明不许使用的外,可以不经著作权人许可,在教科书中汇编已经发表的作品片段或者短小的文字作品、音乐作品或者单幅的美术作品、摄影作品,但应当按照规定支付报酬,指明作者姓名、作品名称,并且不得侵犯著作权人依照本法享有的其他权利。
5、制作和提供课件的法定许可、信息条例第八条:为通过信息网络实施九年制义务教育或者国家教育规划,可以不经著作权人许可,使用其已经发表作品的片断或者短小的文字作品、音乐作品或者单幅的美术作品、摄影作品制作课件,由制作课件或者依法取得课件的远程教育机构通过信息网络向注册学生提供,但应当向著作权人支付报酬。
转载:CC++关于string.h头文件和string类
转载:CC++关于string.h头⽂件和string类学习C语⾔时,⽤字符串的函数例如stpcpy()、strcat()、strcmp()等,要包含头⽂件string.h 学习C++后,C++有字符串的标准类string,string 类也有很多⽅法,⽤string类时要⽤到string.h头⽂件。
我现在看vc的书上也有CString类,这个要包含什么,怎么⽤?我现在很迷惑,这两个 string.h有什么区别。
是怎么回事且看⼀:这两个⼀个是标准C库的,定义了⼀些字符串的处理函数.⼀个是标准C++库的,定义了标准C++的std::string类. 要⽤这个类要包含头⽂件<string>...如下; #include <string> using namespace std;//关于名字空间有兴趣⾃⼰查去,⼀般⽤标准库这句就⾏了当然标准C库也是标准C++库的⼀部分,要⽤标准C库⾥的处理函数...如下: #include <string.h>//所以你⽤这句包含的是标准C库的头⽂件 ...或者⽤如下C++风格的,它们是等价的,不过⽐较推荐: #include <cstring> using namespace std;CString类是MFC的类,...不搞Windows MFC编程⽤不到且看⼆:#include < string .h >void main() {string aaa = " abcsd d " ;printf( " looking for abc from abcdecd %s/n " , (strcmp(aaa, " abc " )) ? " Found " : " Not Found " );} 不能正确执⾏,提⽰说是string类型没有定义 ⽽下⾯:#include < string >using namespace std; void main(){ string aaa = " abcsd d " ;printf( " looking for abc from abcdecd %s/n " , (strcmp(aaa, " abc " )) ? " Found " : " Not Found " ); } 这⾥的string编译器就认识了,但是strcmp就不认识了呢? ⼀般⼀个C++的⽼的带“。
C语言中size_t类型详细说明【转载】
C语⾔中size_t类型详细说明【转载】来看看⽹上的⼀些说法:C语⾔ size_t到底是个什么东东?⼤神求解1. 简单理解为 unsigned int就可以了2. 这是在不同的机器⾥⾯的的头⽂件定义的相应宏定义,实际上是unsigned int。
3. ⽆符号整型。
4. ⼤部分情况下是unsigned int5. 有⼀说法,数组下标应为size_t类型,具体size_t占⼏个字节与具体环境有关在c语⾔的很多库函数中,函数原型中,参数类型都是size_t。
但是在我们编写程序时size_t类型却很少有所使⽤。
那么这个类型到底有什么作⽤呢使⽤size_t可能会提⾼代码的可移植性、有效性或者可读性,或许同时提⾼这三者。
在标准C库中的许多函数使⽤的参数或者返回值都是表⽰的⽤字节表⽰的对象⼤⼩,⽐如说malloc(n) 函数的参数n指明了需要申请的空间⼤⼩,还有memcpy(s1, s2, n)的最后⼀个参数,表明需要复制的内存⼤⼩,strlen(s)函数的返回值表明了以’\0’结尾的字符串的长度(不包括’\0’),其返回值并不是该字符串的实际长度,因为要去掉’\0’。
或许你会认为这些参数或者返回值应该被申明为int类型(或者long或者unsigned),但是事实上并不是。
C标准中将他们定义为size_t。
标准中记载malloc的申明应该出现在,定义为:void *malloc(size_t n);memcpy和strlen的申明应该出现在中:void *memcpy(void *s1, void const *s2, size_t n);size_t strlen(char const *s);size_t还经常出现在C++标准库中,此外,C++库中经常会使⽤⼀个相似的类型size_type,⽤的可能⽐size_t还要多。
据我所知,⼤部分的C和C++程序员害怕这些库使⽤size_t,因为他们不知道size_t代表什么或者为什么这些库需要使⽤它,归根结底,原因在于他们什么时候什么地⽅需要⽤到它。
【转载】gcc命令-c-o-E-S
【转载】gcc命令-c-o-E-S本⽂转载⾃:Linux命令⼤全gcc命令使⽤GNU推出的基于C/C++的编译器,是开放源代码领域应⽤最⼴泛的编译器,具有功能强⼤,编译代码⽀持性能优化等特点。
现在很多程序员都应⽤GCC,怎样才能更好的应⽤GCC。
⽬前,GCC可以⽤来编译C/C++、FORTRAN、JAVA、OBJC、ADA等语⾔的程序,可根据需要选择安装⽀持的语⾔。
语法gcc(选项)(参数)选项-o:指定⽣成的输出⽂件;-E:仅执⾏编译预处理;-S:将C代码转换为汇编代码;-:显⽰警告信息;-c:仅执⾏编译操作,不进⾏连接操作。
参数C源⽂件:指定C语⾔源代码⽂件。
实例常⽤编译命令选项假设源程序⽂件名为.c⽆选项编译链接gcc test.c将test.c预处理、汇编、编译并链接形成可执⾏⽂件。
这⾥未指定输出⽂件,默认输出为a.out。
选项 -ogcc test.c -o test将test.c预处理、汇编、编译并链接形成可执⾏⽂件test。
-o选项⽤来指定输出⽂件的⽂件名。
选项 -Egcc -E test.c -o test.i将test.c预处理输出test.i⽂件。
选项 -Sgcc -S test.i将预处理输出⽂件test.i汇编成test.s⽂件。
选项 -cgcc -c test.s将汇编输出⽂件test.s编译输出test.o⽂件。
⽆选项链接gcc test.o -o test将编译输出⽂件test.o链接成最终可执⾏⽂件test。
选项 -Ogcc -O1 test.c -o test使⽤编译优化级别1编译程序。
级别为1~3,级别越⼤优化效果越好,但编译时间越长。
多源⽂件的编译⽅法如果有多个源⽂件,基本上有两种编译⽅法:假设有两个源⽂件为test.c和testfun.c多个⽂件⼀起编译gcc testfun.c test.c -o test将testfun.c和test.c分别编译后链接成test可执⾏⽂件。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
【转】C#中继承实现父类方法、重写、重载
继承是派生类()去实现(重写<override>、重构<new>)基类()的方法或属性。
从而获取在派生类中要实现的功能。
子类调用父类构造方法,在父类中有个实现姓名和年龄的构造方法但是中子类也要实现这样的功能这时子类不用再次去写这个功能只要去调用父类的功能即可。
public class Person
{
private string _name = null;
private int _age = 0;
public Person(string name, int age)//父类的构造方法
{
this._name = name;//获得参数的值
this._age = age;
Console.WriteLine("您的姓名是{0},您的年龄是{1}.",
this._name, this._age);
}
}
public class Studnet : Person
{
private int _id;
public Studnet(string name, int age, int IDCard):base(name,age)
//子类构造方法继承父类构造方
//把接受到的name、age两个参数交给父类的构造方法去处理
{
this._id = IDCard;
Console.WriteLine("您的身份证号码为{0}",this._id);
}
}
class Program
{
static void Main(string[] args)//主函数
{
Studnet stu = new Studnet("benshou", 12, 99999);
Console.ReadLine();
}
}
实现效果
您的姓名是benshou,您的年龄是12.
您的身份证号码为99999
在C#中定义了,子类去调用父类的方法时,会先去执行父类的方法之后再去执行子类的方法
还是以子类继承父类,现在是子类实现父类的重写和重载
重写只是对方法里面的功能实现重新做的了编写,并没有对方法的参数进行添加、改变、删除
重载则是对方法参数的个数、位置、参数类型进行了改变。
重写ShowME方法
public class Person
{
public void ShowME(string name,string school,string Class)
{
Console.WriteLine("我在{0}学习",Class);
Console.WriteLine("我叫{0}.我毕业与{1}",name,school);
}
}
public class Studnet : Person
{
public void ShowME(string name,string school, string Class)
//重写了父类的ShowME方法
{
Console.WriteLine("姓名{0}\n毕业学校{1}\n曾读班级{2}",
name,school,Class);
}
}
}
class Program
{
static void Main(string[] args)//主函数
{
Student stu = new Studnet();
stu.ShowME("benshou","浙江金融职业学院","电子商务(7)班"); Console.ReadLine();
}
}
实现效果
姓名benshou
毕业学校浙江金融职业学院
曾读班级电子商务(7)班
重载ShowME方法
public class Person
{
public void ShowME(string name,string school,string Class)
{
Console.WriteLine("我在{0}学习",Class);
Console.WriteLine("我叫{0}.我毕业与{1}",name,school);
}
}
public class Studnet : Person
{
public void ShowME(string name)
{
Console.WriteLine("姓名{0}",name);
}
}
class Program
{
static void Main(string[] args)//主函数
{
Studnet stu = new Studnet();
stu.ShowME("benshou");
Console.ReadLine();
}
}
实现效果
姓名benshou
子类重载父类方法,子类必须指定重载的关键字(new),而父类被重载的方法则可以不用指定哪个方法被重载的关键字(virtual)。
重载一个方法,是对一个方法重新进行了编写从方法的参数到方法体,唯独方法的名称没有进行改变。
重载也可以对原来没有返回类型的方法(void),改变为有返回类型的方法。
总体来讲,重载处了方法名不能被改变为另外什么都能重新定义(方法作用域、返回类型、方法体、方法参数)
以上我个人对继承的了解。