HES_C的博客

昨天做梦，有朋友发现这种方式太浪费内存，写法和使用方式也过于繁琐，醒来后深度思考了一下。对以上又做了一次修改，这种精简了pack数据结构，也简化了用法，也节约了内存。首先定义新的数据结构，没错，这次就只剩下结构体了。//The copy function#define MCOPY(S,T,L) do{unsigned int i=0;for(;i<L;i++)S[i]=T[i];}while(0)//define a union to map the struct//this i.

/* 前言： * 我们在使用buf数字传输数据的时候，通常会用来传输各种数据类型。 * 一般的，我们会传输 char，short ,int ,float等，也包括各种 unsigned. * * * 一般的思路我们在发送的时候，会把数据一个个拆解成一个个byte,然后按顺序放到buf。 * 在拿数据的时候，再一个一个的byte去拼接成具体数据，如下： * //包装数据 buf[0]=Para.nv_list.sn>>24&0xff; buf[1]=P.

看标题好像有点不明白啊,兄弟?那我稍微的解释一下>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>我写过很多个socket程序的demo,每一个程序要发送什么数据,都要改双方的接收和发送函数,这样显得太笨拙了,而且根本无法移植好吗....后面我想到了模板函数::::::::::::::::::::::::::::::::::::::::大家都知道模板可以支持

/* 可变参数的函数, 类型类似于printf()函数，接收的参数不确定，但并不重载，我们知道c语言不纯在什么重载。 那么如果我们的函数也需要这样的一个功能呢？ 有人又会说，main()函数不也是不定参数？ 没错，main函数那种指针数组确实也可以做到，不过那种其实是一个参数 说白了，就是传了一个指针而已，而并不是可变参数 其实真正的可变参也是这样的原理，不过机制有所不同。

1）#define 的符号用法 ##连接 #define con(x,y) x##y n=con(123,456) -> n=123456 字符串也是类似 #@转字符 #define tochar(x) #@x x不超过3位 char a=tochar(1) -> a='1' #转字符串 #define tostring(x) #x char *str =tostring

/*虚函数和纯虚函数的区别？虚函数在定义的时候要实现函数体：virtual void fun();纯虚函数不能实现函数体：virtual void fun()=0;在继承的时候纯虚函数必须实现。析构可以不实习我想这就是两者的基本区别把，*/#include "iostream"using namespace std;class A{public: A(

/*下面程序一个A类析构函数是虚函数，为什么这么做呢？我们可以看下后面的运行结果总结，我发现在使用多态的时候,如果基类析构不是虚函数那么子类将不会被析构,从而会造成内存泄露等问题。非常危险*/#include "iostream"using namespace std;class A{public: A(){cout<<"构造A"<<endl;} virtual

/*下面程序有一个B类，有一个a函数，调用了自身的b函数思考：如果有一天我的这个B类不错，别人想用使用，他拿过去的时候发现b函数并不能满足他的要求，但是功能就是这个样子那么怎么解决呢？为了方便给别人使用，并且不破坏我的B类，我就把b函数定义成虚函数，别人可以通过继承来重写它。这样这个问题就解决了。下面这个show函数就是用的多态概念，在不改变的show函数的情况下，show函

/* 下面程序有一个基类A，有一个变量一个函数 B继承了A C也继承了A 如果D继承了B,C，那么D就有两份i，和2个show()函数，那它改选择谁呢？ 所以我们就用到了虚继承，被继承的类叫做虚基类，class B:virtual public A 这样做，D就只有一份数据了*/#include "iostream"using namespace std;class

#include"iostream"using namespace std;class s{ class test { public: static int a; static int *b; test(){printf("构造函数\n");} ~test(){printf("析构函数\n");}

#include "stdio.h"#include "string.h"#include "malloc.h"/*--------------------------------------------------------函数名: int str_zi(char *,char *)函数功能： 判断一个字符串是另一个字符串的子串作者: HES输入参数: 父串输出参数： 子

上一篇说到串口协议的封包与拆包，主要要是应用于单片机与单片机通讯，或者与上位机程序通讯，这里我是与上位机程序通讯。思路：因为此功能是用c语言写的，所有在单片机上可以使用，在pc机上也是可以使用的。这是单片机主函数代码： int main(void) { delay_init(); //延时函数初始化 NVIC_PriorityGroupConfig(NVIC

 在picture控件上面绘制波形，主要通过控件DC来绘制，通过随机数获取新的点，通过定时器来刷新界面。首先在MFC界面中放一个picture控件，大小尽量拖大点。在程序初始化的地方初始化随机函数种子 // 以时间为种子来构造随机数生成器 srand((unsigned)time(NULL)); // 启动定时器，ID为1，定时时间为200ms...

关于USMART调试组件，用过的大家都不陌生，应该是出自于原子哥的教程。因为我百度一看全是原子哥的源码，原子哥这个模块写得确实不错，让我吸取了不少。不过最近发现这个组件有一个很大的问题，函数所有的参数都是int，也就是说所支持的函数不能有其他数据类型，比如常用的float。数据类型这么多，其实用到的就是int和float。（说明：虽然可以用其它方式来弥补，但是还是让人不舒服）下...

/* 首先要先理解两个类型的区别。 先说函数指针： void (*fun)(void);     这个就是一个函数指针了，函数的参数为空 void (*fun)(int); 这个也是一个函数指针，函数参数有个int 来看看void*类型： void *fun; 这样定义看起来很抽象，有没有，对于没有用过空类型的同学来说， 这样定义确实会让人一脸...

作为嵌入式程序员，位结构体可以说是非常的重要，因为这样可以让你节约大多的内存。具体就不介绍了，看看代码应该都能懂了。#include "iostream"//位结构体的使用#define u8 unsigned char #define u16 unsigned short//位结构体struct data{ u8 flag1: 1; //占用1位 所有最多表示0或...

int main() { printf("%d\n",__LINE__);//显示所在行号 printf("%s\n",__func__);//显示所在函数 printf("%s\n",__TIME__);//显示当前时间 printf("%s\n",__DATE__);//显示当前日期 printf("%s\n",__FILE__)

FILE *fp;int flen;/* 以只读方式打开文件 */if((fp = fopen ("1.txt","r"))==NULL){printf("\nfile open error\n");exit(0);}fseek(fp,0L,SEEK_END); /* 定位到文件末尾 */flen=ftell(fp); /* 

//设置数据生成时间 //需要添加 time.h time_t now ; struct tm *tm_now ; time(&now) ; tm_now = localtime(&now) ; char buff[500]; sprintf(buff,"data_%d-%d-%d-%d-%d-%dinfo.xls",tm_now->tm_year+1900, tm_n

其实xls就是一个普通文件，我们操作的时候可以把它看成是一个很大的二维数组。具体看一下代码就明白了。 // 文件IO.cpp : 定义控制台应用程序的入口点。//#include "stdafx.h"int buf[3][4]={1,2,3,4,5,6,7,8,9,10,11,12};void write_xls(void ) { FILE *fp =

其实char**   str 这个类型就是一个二维数组的指针我们知道一个char*  str是可以指向一个字符串的，那么2个*就是指向指针(字符串)的指针，所以(char*)*str,char*(*str),char**str都是一样的。下面看一个实例就很清楚了#include "stdio.h"#include "malloc.h"int main(){ char**str

静态联编；动态联编；虚函数在C++中，联编是指一个计算机程序的不同部分彼此关联的过程。按照联编所进行的阶段不同，可分为两种不同的联编方法：静态联编和动态联编。    1. 静态联编静态联编是指联编工作在编译阶段完成的，这种联编过程是在程序运行之前完成的，又称为早期联编。要实现静态联编，在编译阶段就必须确定程序中的操作调用（如函数调用）与执行该操作代码间的关系，确定这种关系称为束

class A{};class B :public A{};上面是继承的基本写法继承方式:public:公有继承,不改变基类的成员可见性(在本类中所继承的基类的那些成员,可见性不变),public-->publicprotected--->protectedprivate--->privateprotected:保护继承,基类的public成员变

c++模板的使用

#include using namespace std;class Automat{ friend class Boss;//声明Boss类是我的朋友,可以查看我的所有变量 //friend Boss::open(Automat &automat); friend void localopen(void); //声明该函数是我的朋友,可以查看所有变量 p

static 在c语言里面，static有两层含义：（1）      只能在某个范围里使用。在文件里定义的static变量，只能在本文件使用。（2）      static变量具有持久性，实际上是一个全局变量。 C++里，static可以修饰类的实例、成员函数、成员变量。 （1）      对于类的实例而言，static的用法和作用与c是一样。（2）      

class A{public: A(){}//构造函数 ~A(){};//析构函数};构造函数创建类的实例的时候，会自动调用构造函数。如果没有自己实现构造函数，则系统会自动生成一个默认的构造函数。如果已经实现了，那么默认的构造函数会失效。构造函数可以重载。函数名和类名一致。函数没有返回值。析构函数 类生命周期结束后，用来清理类里的资源的函数。如果没有

面向对象编程的三大特点：封装、继承、多态。封装：将对象里的数据隐藏起来，公开少数的一些，以保护它们不被访问。在类里用private将之后的数据设为私有数据，外界不可访问的。public的数据可以访问。protected的数据可以被子类访问，不可被外界其它类访问。事实上，所有的数据都应设为私有，然后用成员函数来给外界提供访问的接口。用struct创建的类，成员默认

C++里的内存分配内存申请：new new []int *p=new int;int *p1=new int[10];内存的释放：deletedelete []delete p;delete[] p1;

C++函数重载的办法。只要参数类型、个数不同，那么允许用同一个函数名。例如:add(int a,int b)add(int a, int b,int c)

/*静态联编(static binding):在编译阶段,确定函数的跳转地址.早期联编.动态联编(dynamic binding):在运行阶段,根据指向的对象,动态地确定跳转地址.晚期联编.*/#include using namespace std;class Animal{ public: virtual void move(void) {

#include "iostream"using namespace std;class point{ private: int x; int y; public: point(){} point(int _x,int _y):x(_x),y(_y){} //声明成有缘函数 friend ostream& operator<<(ostream&

c++自定义命名空间

相同点：都可用于申请动态内存和释放内存不同点：（1）操作对象有所不同。malloc与free是C++/C 语言的标准库函数，new/delete 是C++的运算符。对于非内部数据类的对象而言，光用maloc/free 无法满足动态对象的要求。对象在创建的同时要自动执行构造函数， 对象消亡之前要自动执行析构函数。由于malloc/free 是库函数而不是运算符，不在编译器控制权限之内

指针数组：int *a[3]数组的元素是指针元素表示：*a[i]==*(a[i]) //[] 优先级高于*#include "iostream"#include "cstdlib"using namespace std;int main(){ int *a[3]; int b=1; int c=2; int d=3; a[0]=&b

PS：用函数指针访问类内部函数约束1只能访问public和static，virtual#include "iostream"using namespace std;class A{ private: void fun() { cout<<"this is 0"<<endl; } public:

#include "iostream"using namespace std;class A{ private: int a; public: int b; static int c; const int d=10;}; int A::c=10; int main(){ //方式1,访

#include"iostream"using namespace std;typedef void(*pfun)();void fun1(){ cout<<"this is 1"<<endl;} void fun2(){ cout<<"this is 2"<<endl;}//函数接口void funs(pfun p){ (*p)();}int m

#include "iostream"using namespace std;void fun2(){ cout<<"this is 2"<<endl;}void fun3(){ cout<<"this is 3"<<endl;}void fun4(){ cout<<"this is 4"<<endl;}int main(){ //方式一 c

#include "iostream"using namespace std;templateclass arry{ private: T *p; unsigned int size; public: arry(){} arry(unsigned int _size):size(_size){ p=(T*)malloc(_size*sizeof(T))