Richard zeng 3/19/2006 10:50:36 AM
这几天又把以前的
C
课程翻了出来
,
因为自己对
C
的指针和数组不是很
DEV.
模拟
C
库函数中的转化大小写函数
.
//
转换成大写
,
函数参数为字符数组
//
利用字符串数组的结尾都是
\0
void
ToUpper(chars[])
{
int
i=0;
while(s[i++]!='\0' )
{
//
判断是否是小写字母
if(s[i]>='a' && s[i]<='z' )
s[i] -= 32; //
小写字母比大写字母的
ASCII
大
32
}
}
//
转换成大写
,
函数参数为字符指针
void
ToUpperPtr(char* s)
{
while(*s != '\0')
{
//
判断是否是小写字母
if(*s >='a' && *s <='z')
*s -= 32; //
小写字母比大写字母的
ASCII
大
32
s++; //
指针的地址
++
}
}
封装了一下波形显示，发现不是很难
WaveShow_src.rar
ASCII码表大家都很熟悉了吧，利用码的排列规律，我们可以很容易的实现一些操作，比如判断是否是数字、大小写转换等。
这里写大小写转换的函数:
char toUpper(const char& ch)
{
return ch & 0x5F;
}
char toLower(const char& ch)
{
return ch | 0x20;
} |
函数原理：大小写字母的差是32，比如大写的A是65，小写的A是97，所以我们把右边数第6位置0或者1就能实现大小写转换。转换成大写时，把第6位置0，用ch & 0x5F实现。转换成小写时置1，用ch | 0x20实现。怎么样，相当的简单吧，由此，我们可以写string类的toUpper和toLower函数了。^_^，更多技巧尽在探索中。
CMPP协议的全称是中国移动通信互联网短信网关接口协议，它是联想亚信公司根据SMMP协议为中国移动量身定做的，是符合中国国情的一个短信协议，闲话不多说了，说说CMPP的主要功能吧。（1）短信发送（short message mobile originate）MO，就是手机给SP发短信；（2）短信接受（short message mobile terminated）MT，这个就是SP给手机发的短信了，通常我们手机上收到的不良短信就是SP给我们的MT。CMPP协议的通信基础是TCP/IP为底层通信承载的，连接方式是长连接方式。SP与ISMG之间，SMSC和ISMG之间的交互过程中均采用异步方式，即任一个网元在收到请求消息后应立即回应。
下面看看它的消息定义：CMPP中的消息分为消息头和消息体。消息头定义如下
|
字段名 |
字节数 |
类型 |
描述 |
|
Total_Length |
4 |
Unsigned Integer |
消息总长度(含消息头及消息体) |
|
Command_Id |
4 |
Unsigned Integer |
命令或响应类型 |
|
Sequence_Id |
4 |
Unsigned Integer |
消息流水号,顺序累加,步长为1,循环使用（一对请求和应答消息的流水号必须相同） |
那么下面就是SP连接到ISMG上了，看它的Bind连接消息定义
|
字段名 |
字节数 |
属性 |
描述 |
|
Source_Addr |
6 |
Octet String |
源地址，此处为SP_Id，即SP的企业代码。 |
|
AuthenticatorSource |
16 |
Octet String |
用于鉴别源地址。其值通过单向MD5 hash计算得出，表示如下：
AuthenticatorSource =
MD5（Source_Addr+9 字节的0 +shared secret+timestamp）
Shared secret 由中国移动与源地址实体事先商定，timestamp格式为：MMDDHHMMSS，即月日时分秒，10位。 |
|
Version |
1 |
Unsigned Integer |
双方协商的版本号(高位4bit表示主版本号,低位4bit表示次版本号)，对于3.0的版本，高4bit为3，低4位为0 |
|
Timestamp |
4 |
Unsigned Integer |
时间戳的明文,由客户端产生,格式为MMDDHHMMSS，即月日时分秒，10位数字的整型，右对齐 。 |
根据上的定义我们可以写出的代码，如下，在VC环境下编写的
/*
*函数功能：建立和CMPP网关的直接通路
*输入条件：SP用户名const char *UserName,SP密码const char *PWD
*/
void Ccmpp_API::CmppConnect(const char *UserName, const char *PWD)
{
char netbuf[100];
CMPP_CONNECT *bufer;
bufer=(CMPP_CONNECT*)netbuf;
memset(bufer, 0, 100);
bufer->nTotalLength = htonl(39);//CMPP_CONNECT消息总长度
bufer->nCommandId = htonl(CMPP_CONNECT_tag);//消息标志
//自动产生SeqId号
if (sequenceid == 123456789i32)
{
sequenceid = 1;
}else{
sequenceid++;
}
bufer->nSeqId = htonl(sequenceid);
int MD5Len;
MD5_CTX md5;//MD5源字串
CTime TimeData = CTime::GetCurrentTime();
CString timestamp = TimeData.Format("%m%d%H%M%S");
unsigned char md5source[29];
int Len1 = strlen(UserName);
int Len2 = strlen(PWD);
MD5Len = Len1 + 9 +Len2 + timestamp.GetLength();
memset(md5source, 0, MD5Len);
memcpy(bufer->sSourceAddr, UserName, Len1);
memcpy(md5source, UserName, Len1);
for (int j = 0; j<Len2; j++)
{
md5source[j + Len1 + 9] = PWD[j];
}
for (int i=0;i<timestamp.GetLength();i++)
{
md5source[i + Len2 + Len1 + 9]=timestamp[i];
}
//进行md5加密转换
md5.MD5Update(md5source, MD5Len);
md5.MD5Final(md5source);
memcpy(bufer->sAuthSource, md5source, 29);
bufer->cVersion = 0x30;
bufer->nTimeStamp = htonl(atoi(timestamp));
CmppSocket.Send(bufer, 39, 0);//把消息打包发送
return;
}
今天就到这，下次再写，欢迎交流！
posted on 2006-03-15 07:58
炙热的太阳 阅读(38)
评论(2) 编辑 收藏 收藏至365Key
FeedBack:
2006-03-15 10:38 |
you say:
SP与ISMG之间，SMSC和ISMG之间的交互过程中均采用异步方式，即任一个网元在收到请求消息后应立即回应。
既然是异步方式，就不是收到请求后立即回应，否则就是同步方式了
据我所知，CMPP采用的基于滑动窗口的异步方式，默认情况下可以发最多16的CMPP package,而不必等待他们的resp.
回复
2006-03-15 11:21 |
是的，你说的没有错。
消息是采用并发方式发送，加以滑动窗口流量控制，窗口大小参数W可配置，现阶段的配置为16，即接收方在应答前一次收到的消息最多不超过16条。这是它们之间的通信方式。
而SP与ISMG之间，SMSC和ISMG之间的交互过程中均采用异步方式，即任一个网元在收到请求消息后应立即回应。这是它们交互过程中的应答方式。即收到一个消息就应该回一个回应消息，而不管对方是否收到，所以上面讲的并没有错哟。
回复
摘要: 最近在VS2005下实现一个模版堆栈时，想重载一下输出运算符。结果老是遇到问题，如何都过不去，想不想去都不明白。还望高手指教。 一开始同样的程序在VC2005和VC6.0下编译都没问题，但是一到链接的时候就出现问题了。都提示如下错误：
error LNK2019: 无法解析的外部符号 "cla...
阅读全文
对于回调函数的编写始终是写特殊处理功能程序时用到的技巧之一。先介绍一下回调的使用基本方法与原理。
1、在这里设：回调函数为A()(这是最简单的情况，不带参数，但我们应用的实际情况常常很会复杂)，使用回调函数的操作函数为B()， 但B函数是需要参数的，这个参数就是指向函数A的地址变量，这个变量一般就是函数指针。使用方法为：
int A(char *p); // 回调函数
typedef int(*CallBack)(char *p) ; // 声明CallBack 类型的函数指针
CallBack myCallBack ; // 声明函数指针变量
myCallBack = A; // 得到了函数A的地址 B函数一般会写为 B(CallBack lpCall,char * P,........); // 此处省略了p后的参数形式 。
所以回调机制可解为，函数B要完成一定功能，但他自己是无法实现全部功能的。 需要借助于函数A来完成，也就是回调函数。B的实现为：
B(CallBack lpCall,char *pProvide)
{
........... // B 的自己实现功能语句
lpCall(PpProvide); // 借助回调完成的功能 ，也就是A函数来处理的。
........... // B 的自己实现功能语句
}
// -------------- 使用例子 -------------
char *p = "hello!";
CallBack myCallBack ;
myCallBack = A ;
B(A, p); 以上就是回调的基本应用，本文所说的变身，其实是利用传入不同的函数地址，实现调用者类与回调函数所在类的不同转换。
1、问题描述
CUploadFile 类完成数据上传，与相应的界面进度显示。
主要函数Send(...) 和回调函数 GetCurState() ;
class CUploadFile : public CDialog
{
......
int Send(LPCTSTR lpServerIP, LPCTSTR lpServerPort, LPCTSTR UploadFilePath) ;
static int GetCurState(int nCurDone, int nInAll, void * pParam) ;
......
}
int CUploadFile ::Send(LPCTSTR lpServerIP, LPCTSTR lpServerPort, LPCTSTR UploadFilePath)
{
... // 导出传输数据的函数
int ret = Upload( (LPSTR)(LPCTSTR)m_strData,
GetCurState, // 在这个回调函数中处理界面
this, // CUploadFile 的自身指针 ，也就是pParam 所接受的参数
(LPSTR)(LPCTSTR)UploadFilePath,
"",
"",
);
}
int CUploadFile ::GetCurState(int nCurData, int nInAll, void * pParam)
{
.........
UploadFile *pThis = (UploadFile *)pParam; // nCurData 当前以传出的数据量
// nInAll 总的数据量
// 有了pThis可以对界面进行各种操作了。
.............
} 但大家仔细观察就可以发现，这个类把数据传送和界面显示聚和到了一起，不容易得到复用。而且在复用过程中需要改动较多的地方 。
请大家记住现在的回调函数传入的类本身的静态成员函数。
现在我们把数据的传送和界面的显示分离。回调则要传入的是界面处理类的静态函数。
界面处理类 CShowGUI,数据上传类 CUploadData
class CUploadData
{
......
typedef int(*SetUploadCaller)(int nCurData, int nInAll, void * pParam);
int UploadFile(LPCTSTR lpFileNamePath,LPVOID lparam,SetUploadCaller Caller );
// 接受外界出入的参数,主要是回调函数的地址通过参数Caller,
int Send(LPCTSTR lpServerIP, LPCTSTR lpServerPort, LPCTSTR UploadFilePath) ;
...... // 注意此时不在需要GetCurState 函数了 。
}
class CShowGUI: public CDialog
{
.......
typedef int(*SetUploadCaller)(int nCurData, int nInAll, void * pParam);
void SetCallBack(LPCTSTR strPath);
static int GetCurState(int nCurData, int nInAll, void * pParam) ;
CUploadData m_Uploa
d ; // 数据上传类是界面显示类的一个成员变量。
.......
}
void CShowGUI :: SetCallBack(LPCTSTR strPath)
{
CUploadData myUploadData ;
SetUploadCaller myCaller; // 声明一个函数指针变量
myCaller = CurState ; // 取得界面处理函数的地址
myUploadData .UploadFile(strPath,this,myCaller); // 界面处理类的函数传入,实现了数据传入与界面处理的分离 .
} 通过上面的演示做到了界面与数据的分离,回调函数分别扮演了不同角色,所以随着处理问题的不同应灵活应用，但同样因为处理数据类不知道界面处理类或外部调用类的类型，而更无法灵活地处理界面的不同显示方式。这方面还希望喜欢钻研技术的朋友继续研究。
指针，在C/C++语言中一直是很受宠的；几乎找不到一个不使用指针的C/C++应用。用于存储数据和程序的地址，这是指针的基本功能。用于指向整型数，用整数指针(int*)；指向浮点数用浮点数指针(float*)；指向结构，用对应的结构指针(struct xxx *)；指向任意地址，用无类型指针(void*)。
有时候，我们需要一些通用的指针。在C语言当中，(void*) 可以代表一切；但是在C++中，我们还有一些比较特殊的指针，无法用(void*)来表示。事实上，在C++中，想找到一个通用的指针，特别是通用的函数指针简直是一个“不可能任务”。
C++是一种静态类型的语言，类型安全在C++中举足轻重。在C语言中，你可以用void*来指向一切；但在C++中，void*并不能指向一切，就算能，也失去了类型安全的意义了。类型安全往往能帮我们找出程序中潜在的一些BUG。
下面我们来探讨一下，C++中如何存储各种类型数据的指针。
C++指针探讨 （一）数据指针 沐枫网志 1. 数据指针
数据指针分为两种：常规数据指针和成员数据指针
1.1 常规数据指针
这个不用说明了，和C语言一样，定义、赋值是很简单明了的。常见的有：int*, double* 等等。
如：
int value = 123;
int * pn = &value;
1.2 成员数据指针
有如下的结构：
struct MyStruct
{
int key;
int value;
};
现在有一个结构对象:
MyStruct me;
MyStruct* pMe = &me;
我们需要 value 成员的地址，我们可以：
int * pValue = &me.value;
//或
int * pValue = &pMe->value;
当然了，这个指针仍然是属于第一种范筹----常规数据指针。
好了，我们现在需要一种指针，它指向MyStruct中的任一数据成员，那么它应该是这样的子：
int MyStruct::* pMV = &MyStruct::value;
//或
int MyStruct::* pMK = &MyStruct::key;
这种指针的用途是用于取得结构成员在结构内的地址。我们可以通过该指针来访问成员数据：
int value = pMe->*pMV; // 取得pMe的value成员数据。
int key = me.*pMK; // 取得me的key成员数据。
那么，在什么场合下会使用到成员数据指针呢？
确实，成员指针本来就不是一种很常用的指针。不过，在某些时候还是很有用处的。我们先来看看下面的一个函数：
int sum(MyStruct* objs, int MyStruct::* pm, int count)
{
int result = 0;
for(int i = 0; i < count; ++i)
result += objs[i].*pm;
return result;
}
这个函数的功能是什么，你能看明白吗？它的功能就是，给定count个MyStruct结构的指针，计算出给定成员数据的总和。有点拗口对吧？看看下面的程序，你也许就明白了：
MyStruct me[10] =
{
{1,2},{3,4},{5,6},{7,8},{9,10},{11,12},{13,14},{15,16},{17,18},{19,20}
};
int sum_value = sum(me, &MyStruct::value, 10);
//计算10个MyStruct结构的value成员的总和： sum_value 值 为 110 (2+4+6+8+
+20)
int sum_key = sum(me, &MyStruct::key, 10);
//计算10个MyStruct结构的key成员的总和： sum_key 值 为 100 (1+3+5+7++19)
也许，你觉得用常规指针也可以做到，而且更易懂。Ok，没问题：
int sum(MyStruct* objs, int count)
{
int result = 0;
for(int i = 0; i < count; ++i)
result += objs[i].value;
return result;
}
你是想这么做吗？但这么做，你只能计算value，如果要算key的话，你要多写一个函数。有多少个成员需要计算的话，你就要写多少个函数，多麻烦啊。
C语言的指针相当的灵活方便，但也相当容易出错。许多C语言初学者，甚至C语言老鸟都很容易栽倒在C语言的指针下。但不可否认的是，指针在C语言中的位置极其重要，也许可以偏激一点的来说：没有指针的C程序不是真正的C程序。
然而C++的指针却常常给我一种束手束脚的感觉。C++比C语言有更严格的静态类型，更加强调类型安全，强调编译时检查。因此，对于C语言中最容易错用的指针，更是不能放过：C++的指针被分成数据指针，数据成员指针，函数指针，成员函数指针，而且不能随便相互转换。而且这些指针的声明格式都不一样：
| 数据指针 |
T * |
| 成员数据指针 |
T::* |
| 函数指针 |
R (*)(...) |
| 成员函数指针 |
R (T::*)(...) |
尽管C++中仍然有万能指针void*，但它却属于被批斗的对象，而且再也不能“万能”了。它不能转换成成员指针。
这样一来，C++的指针就变得很尴尬：我们需要一种指针能够指向同一类型的数据，不管这个数据是普通数据，还是成员数据；我们更需要一种指针能够指向同一类型的函数，不管这个函数是静态函数，还是成员函数。但是没有，至少从现在的C++标准中，还没有看到。
沐枫网志 C++指针探讨(三)成员函数指针
自从有了类，我们开始按照 数据＋操作 的方式来组织数据结构；自从有了模板，我们又开始把 数据 和 算法 分离，以便重用，实在够折腾人的。但不管怎么折腾，现在大多数函数都不再单身，都嫁给了类，进了围城。可是我们仍然需要能够自由调用这些成员函数。
考虑一下windows下的定时调用。SetTimer函数的原型是这样的：
UINT_PTR SetTimer(
HWND hWnd,
UINT_PTR nIDEvent,
UINT uElapse,
TIMERPROC lpTimerFunc
);
其中，参数就不解释了，这个函数估计大多数windows开发人员都知道。lpTimerFunc是个会被定时调用的函数指针。假如我们不通过WM_TIMER消息来触发定时器，而是通过lpTimerFunc来定时工作，那么我们就只能使用普通函数或静态函数，而无论如何都不能使用成员函数，哪怕通过静态函数转调也不行。
再考虑一下线程的创建：
uintptr_t _beginthread(
void( *start_address )( void * ),
unsigned stack_size,
void *arglist
); start_address仍然只支持普通函数。不过这回好了，它允许回调函数一个void*参数，它将会arglist作为参数来调用start_address。于是，聪明的C++程序员，就利用arglist传递this指针，从而利用静态函数成功的调用到了成员函数了：
class mythread
{
public:
static void doit(void* pThis)
{
((mythread*)pThis)->doit();
}
void doit(){}
};
main()
{
mythread* pmt = new mythread;
_beginthread(&mythread::doit, 0, (void*)pmt);
}
但是显然，C++程序员肯定不会因此而满足。这里头有许多被C++批判的不安定因素。它使用了C++中被认为不安全的类型转换，不安全的void*指针，等等等等。但这是系统为C语言留下的调用接口，这也就认了。那么假如，我们就在C++程序中如何来调用成员函数指针呢？
如下例，我们打算对vector中的所有类调用其指定的成员函数：
#include <vector>
#include <algorithm>
#include <functional>
#include <iostream>
using namespace std;
class A
{
int value;
public:
A(int v){value = v;}
void doit(){ cout << value << endl;};
static void call_doit(A& rThis)
{
rThis.doit();
}
};
int main()
{
vector<A> va;
va.push_back(A(1));
va.push_back(A(2));
va.push_back(A(3));
va.push_back(A(4));
//方法1:
//for_each(va.begin(), va.end(), &A::doit); //error
//方法2:
for_each(va.begin(), va.end(), &A::call_doit);
//方法3:
for_each(va.begin(), va.end(), mem_fun_ref<void, A>(&A::doit));
system("Pause");
return 0;
}
方法1，编译不能通过。for_each只允许具有一个参数的函数指针或函数对象，哪怕A::doit默认有一个this指针参数也不行。不是for_each没考虑到这一点，而是根本做不到！
方法2，显然是受到了beginthread的启发，使用一个静态函数来转调用，哈哈成功了。但是不爽！这不是C++。
方法3，呼，好不容易啊，终于用mem_fun_ref包装成功了成员函数指针。
似乎方法3不错，又是类型安全的，又可以通用－－慢着，首先，它很丑，哪有调用普通C函数指针那么漂亮啊（见方法2），用了一大串包装，又是尖括号又是圆括号，还少不了&号！其次，它只能包装不超过一个参数的函数！尽管它在for_each中够用了，但是你要是想用在超过一个参数的场合，那只有一句话：不可能的任务。
是的，在标准C++中，这是不可能的任务。但事情并不总是悲观的，至少有许多第三方库提供了超越mem_fun的包装。如boost::function等等。但是它也有限制：它所支持的参数仍然是有限的，只有十多个，尽管够你用的了；同样，它也是丑陋的，永远不要想它能够简单的用&来搞定。
也许，以失去美丽的代价，来换取质量上的保证，这也是C++对于函数指针的一种无奈吧……
期待C++0x版本。它通过可变模板参数，能够让mem_fun的参数达到无限个……
－－－－－－－－
BTW: C++Builder扩展了一个关键字 closure ，允许成员函数指针如同普通函数指针一样使用。也许C++0x能考虑一下……
摘要: 1 2 #ifndef _BITMAP_H 3 #define _BITMAP_H 4 5 #include <windows.h> 6 7 void SaveImage(const char ...
阅读全文