C++引用C函数需要的头文件定义
#ifdef __cplusplus
extern "C" {
#endif
int main_sdl(long WinID);
#ifdef __cplusplus
}
#endifboost 去除两边空格
#include<boost/algorithm/string.hpp> boost::trim_right(node);
boost::trim_left(node);ｓｈｅｌｌ命令并获取执行结果
//执行一个shell命令，输出结果逐行存储在resvec中，并返回行数 int32_t myexec(const char *cmd, std::vector<std::string> &resvec) { resvec.clear(); FILE *pp = popen(cmd, "r"); //建立管道 if (!pp) { return -1; } char tmp[1024]; //设置一个合适的长度，以存储每一行输出 while (fgets(tmp, sizeof(tmp), pp) != NULL) { if (tmp[strlen(tmp) - 1] == '\n') { tmp[strlen(tmp) - 1] = '\0'; //去除换行符 } resvec.push_back(tmp); } pclose(pp); //关闭管道 return resvec.size(); }
判断是否是数字
bool myisdigit(char* pstr)
{
if(pstr)
{
string numstr(pstr);
if(std::string::npos != numstr.find_first_not_of(" 0123456789"))
{
return false ;
}
else
{
return true ;
}
}
return false ;
}boost 获取时间差：
#include <boost/date_time/posix_time/posix_time.hpp>using namespace boost::posix_time ;
int64_t GetCurrentStamp64()
{
boost::posix_time::ptime epoch(boost::gregorian::date(1970, boost::gregorian::Jan, 1));
boost::posix_time::time_duration time_from_epoch =
// boost::posix_time::microsec_clock::universal_time() - epoch;
boost::posix_time::second_clock::universal_time() - epoch;
//return time_from_epoch.total_microseconds();
return time_from_epoch.total_seconds();
} universal_time 可改 local_time
boost 的 文件目录：
#include <boost/filesystem.hpp>
list<string> getItemListOfpath(string path)
{
list<string> pathList ;
boost::filesystem::path dir2(path);
boost::filesystem::directory_iterator end;
for (boost::filesystem::directory_iterator pos(dir2); pos != end; pos++)
pathList.push_back(pos->path().string());
return pathList ;
}c++获取文件大小
long getFileSize(std::string path_)
{
std::ifstream in(path_);
std::streamoff flen = 0 ;
if( in.is_open() )
{
std::fstream::pos_type cur_pos = in.tellg();
in.seekg( 0L, std::ios::end );
std::fstream::pos_type end_pos = in.tellg();
in.seekg( cur_pos, std::ios::beg );
flen = end_pos;
}else{
std::cout<<"no File detected when getting file size"<<std::endl;
}
return flen;
}c++ 标准库检查文件或目录存在（读取及写入文件内容）：
#include <iostream>
#include <fstream>
using std::fstream ;
bool checkPathExist(string path_)
{
fstream _file;
bool ret = false ;
_file.open(path_.c_str(),std::ios::in);
if(!_file)
{
ret = false ;
cout<<" no such file or directory "<<path_<<endl;
}
else
{
ret = true ;
}
return ret ;
}#include <iostream>
#include <fstream>
using namespace std;
list<string> getFileContentSortByLine(const string &path_)
{
list<string> retlist ;
ifstream infile;
infile.open(path_,ios::in);
if(!infile)
{
cout<<" no such file or directory "<<path_<<endl;
}
else
{
string tmp;
while(!infile.eof())
{
getline(infile, tmp, '\n');
retlist.push_back(tmp);
}
}
infile.close();
return retlist ;
}
string getFileContentString(const string &path_)
{
ifstream in(path_, ios::in);
istreambuf_iterator<char> beg(in), end;
string strdata(beg, end);
in.close();
return strdata ;
}bool writeFileContents(const string &path_,const string &content_)
{
bool ret = false ;
std::ofstream tmpReport(path_);
if(!tmpReport){
std::cout<<"open "<<path_<<" error ,check exists or permission"<<std::endl;
}else{
tmpReport << content_ ;
ret = true ;
}
tmpReport.close();
return ret ;
}C自用简易进度条：
void printfProgressBar(const char* headInfo ,int n)
{
for(int i=0;i<strlen(headInfo);i++)
printf("\b");
printf("\b\b\b");
printf("%s%2d%%",headInfo,n);
fflush(stdout);
}C自用UTC时间
string getUTCTime()
{
char timeString[1024];
time_t t = time(NULL);
tm *tp = localtime(&t);
// beijing time
sprintf(timeString,"%d/%d/%d-%d:%d:%d", tp->tm_mon+1, tp->tm_mday, tp->tm_year + 1900
, tp->tm_hour, tp->tm_min, tp->tm_sec);
return string(timeString);
}C常用Debug信息
printf("[%s][%d][%s][%s] start \n", __FILE__, __LINE__, __TIME__, __func__);
将时间string转换为字符
void Entity_date(string systemtime,char *Nodedate)
{const char *timebuffer = systemtime.c_str() ;
memset(Nodedate,0,30);
memcpy(Nodedate,timebuffer,24);
}
获取系统时间（年月时分秒都有）
string GetTime()
{
time_t rawtime;
struct tm * timeinfo;
time ( &rawtime );
timeinfo = localtime ( &rawtime );
string date = asctime(timeinfo);
cout<<date<<endl;
return date ;
}
还有更简单的方法：
printf("%s\n",__FILE__);//包含当前程序文件名的字符串
// printf("%s\n",__LINE__);//表示当前行号的整数
printf("%s\n",__DATE__); //包含当前日期的字符串
// printf("%s\n",__STDC__);//如果编译器遵循ANSI C标准，它就是个非零值
printf("%s\n",__TIME__); //包含当前时间的字符串
获取时间中的day，修改后可以是其他的
int Get_day_num(string inputtime)
{
uchar location=inputtime.find(":");
string buffer(inputtime,location-5,2);
stringstream stream ; int time_day ;
stream<<buffer;
stream>>time_day ;
return time_day ;
}
输出内容到文件
C 语言版本
void Fprint_String(const char *buffer,const char* Outname,const char* Mode)
{
//a+ : create append w+: create rewrite
FILE *fp ;
fp=fopen(Outname,Mode);
fprintf(fp,"%s",buffer);
fclose(fp);
}
void Fprint_Num(int num,const char *Outname,const char *Mode)
{
FILE *fp ;
fp = fopen(Outname,Mode);
fprintf(fp,"%d ",num);
fclose(fp);
}C输出二进制流到文件
void Fprintf_Binary(const char * Path,char* buf,int Len)
{
FILE * pFile;
pFile = fopen (Path, "wb");
fwrite (buf , sizeof(char), Len, pFile);
fclose (pFile);
}
系统定时boost定时器
void Check(const boost::system::error_code& /*e*/,
boost::asio::deadline_timer* t)
{
cout<<"System running"<<endl;
t->expires_at(t->expires_at() + boost::posix_time::seconds(1));
t->async_wait(boost::bind(Check,
boost::asio::placeholders::error, t));
}
int Time_Show()
{
boost::asio::io_service io;
boost::asio::deadline_timer t(io, boost::posix_time::seconds(5));
t.async_wait(boost::bind(Check,
boost::asio::placeholders::error, &t));
io.run();
return 0;
}
boost::asio::deadline_timer* t)
{
cout<<"System running"<<endl;
t->expires_at(t->expires_at() + boost::posix_time::seconds(1));
t->async_wait(boost::bind(Check,
boost::asio::placeholders::error, t));
}
int Time_Show()
{
boost::asio::io_service io;
boost::asio::deadline_timer t(io, boost::posix_time::seconds(5));
t.async_wait(boost::bind(Check,
boost::asio::placeholders::error, &t));
io.run();
return 0;
}
逐行提取文件
int LoadConfigtxt()
{
char line[60];
char option[30], property[30],buffer[15];
FILE *fp = fopen("/etc/config/Config","a+");
if(fp==NULL)
{
printf("Config text black !!! ");
return 0 ;
}
while(!feof(fp))//end return ture
{
memset(line,0,60); // clean memory line
memset(option,0,30); // clean memory name
memset(property,0,30); // clean ..
fgets(line,60,fp); // read 50 chars frome fp to line untill \t or end of file
sscanf(line, "%s%s%s", buffer,option, property); // format input keyword space
//printf("%s\n",line);
printf("option:%s, property:%s\n",option,property);
Fill_config(option,property,&statebuffer);
}
return 1 ;
}
{
char line[60];
char option[30], property[30],buffer[15];
FILE *fp = fopen("/etc/config/Config","a+");
if(fp==NULL)
{
printf("Config text black !!! ");
return 0 ;
}
while(!feof(fp))//end return ture
{
memset(line,0,60); // clean memory line
memset(option,0,30); // clean memory name
memset(property,0,30); // clean ..
fgets(line,60,fp); // read 50 chars frome fp to line untill \t or end of file
sscanf(line, "%s%s%s", buffer,option, property); // format input keyword space
//printf("%s\n",line);
printf("option:%s, property:%s\n",option,property);
Fill_config(option,property,&statebuffer);
}
return 1 ;
}
C读文件大小和执行shell
#include <stdio.h>
void protect()
{
system("/zchx/ScadaEx/protect.sh");
}
int main()
{
FILE* fp = NULL;
long nFileLen = 0;
fp = fopen("/tmp/log/Scada.log", "rb");
if (fp == NULL)
{
printf("can't open");
return 0;
}
fseek(fp,0,SEEK_END); //定位到文件末
nFileLen = ftell(fp); //文件长度
fclose(fp);
if(nFileLen>1000000)
{
nFileLen = 0;
protect();
}
return 0;
}
void protect()
{
system("/zchx/ScadaEx/protect.sh");
}
int main()
{
FILE* fp = NULL;
long nFileLen = 0;
fp = fopen("/tmp/log/Scada.log", "rb");
if (fp == NULL)
{
printf("can't open");
return 0;
}
fseek(fp,0,SEEK_END); //定位到文件末
nFileLen = ftell(fp); //文件长度
fclose(fp);
if(nFileLen>1000000)
{
nFileLen = 0;
protect();
}
return 0;
}
INT转char并组装成字符串
void itoa_append(int val,char *str,const char *extra)
{
char buffer[20]; memset(buffer,0,20);
sprintf(buffer,"%d",val);
strcat(str,extra);
strcat(str,buffer);
}
{
char buffer[20]; memset(buffer,0,20);
sprintf(buffer,"%d",val);
strcat(str,extra);
strcat(str,buffer);
}
获取随机数
</pre><pre code_snippet_id="84620" snippet_file_name="blog_20131127_2_9192097" name="code" class="plain">int RangeRand(int min,int max)
{
int out ;
srand(time(NULL)); /*init rand seed*/
out=rand()%(max-min)+min; /*rand an integer from min to max*/
}对于List的操作 赋值
// list::assign
#include <iostream>
#include <list>
int main ()
{
std::list<int> first;
std::list<int> second;
first.assign (7,100); // 7 ints with value 100
second.assign (first.begin(),first.end()); // a copy of first
int myints[]={1776,7,4};
first.assign (myints,myints+3); // assigning from array
std::cout << "Size of first: " << int (first.size()) << '\n';
std::cout << "Size of second: " << int (second.size()) << '\n';
return 0;
}内存打印之打印为二进制码以及Hex码
char *ToBinText(char *Addr,unsigned int Length)
{
char *str; str = (char*)malloc(Length*16); memset(str,0,Length*16);
char buf ;
for(int i=0;i<Length;i++)
{
for(int j=0;j<8;j++)
{
if(BIT(7-j)&*Addr)
{
sprintf(&buf,"1");
//qDebug("%s\n",buf);
}else{
sprintf(&buf,"0");
//qDebug("%s\n",buf);
}
strcat(str,&buf);
}
strcat(str,",");
//qDebug("%s\n",str);
Addr+=sizeof(char);
}
//qDebug("%s\n",str);
return str ;
}
char *ToHexText(char *Addr,unsigned int Length)
{
char *str; str = (char*)malloc(Length*4); memset(str,0,Length*4);
char buf[2];
for(unsigned int i=0;i<Length;i++)
{
memset(buf,0,2);
sprintf(buf,"%02x,",(unsigned char)*Addr);
//qDebug("%s\n",buf);
Addr+=sizeof(char) ;
strcat(str,buf);
}
//qDebug("%s \n",str);
return str ;
}
字符串转回Hex码：
char ChangeNum(char* revstr,int length)
{
int num[16]={0};
int count=1;
char result=0;
for (int i=length-1;i>=0;i--)
{
if ((revstr[i]>='0') && (revstr[i]<='9'))
num[i]=revstr[i]-48;//字符0的ASCII值为48
else if ((revstr[i]>='a') && (revstr[i]<='f'))
num[i]=revstr[i]-'a'+10;
else if ((revstr[i]>='A') && (revstr[i]<='F'))
num[i]=revstr[i]-'A'+10;
else
num[i]=0;
result=result+num[i]*count;
count=count*16;//十六进制(如果是八进制就在这里乘以8)
}
printf("hex is:0x%0x\n",result);
return result;
}
char *ToHexFromText(char *StrAddr,int *length)
{
*length = 0 ;
char *p;
char* cmdHex = (char*)malloc(strlen(StrAddr)); memset(cmdHex,0,strlen(StrAddr));
char* cmdOffset = cmdHex ;
p = strtok(StrAddr,",");
if(p){
*cmdOffset = (ChangeNum(p,2)) ;
*length += 1 ;
cmdOffset++ ;
}else{
printf("separateOver \n",p);
}
do
{
p = strtok(NULL,",");
if(p){
*cmdOffset = (ChangeNum(p,2)) ;
*length += 1 ;
cmdOffset++ ;
}else{
printf("separateOver \n",p);
}
} while (p);
*length -=1 ;
return cmdHex;
}多字节移位函数
修正了因为msb或者lsb填写错误造成的，程序崩溃bug
void InitBitArray(int ByteLength, char* ptr_,char *BitArray)
{
//------------------------------------------------------------------------
// Function Introduce
// ------------------------
// Gain Bits of ptr_ , it's bin length is ByteLength
// In Bit Array smallest footer store low bit of high address,
// biggest footer store high bit of low address
//------------------------------------------------------------------------
int footer = 0 ;
ptr_+=sizeof(char)*ByteLength-1;
for(int i=0;i<ByteLength;i++)
{
for(int j=0;j<8;j++)
{
if(*ptr_ & Bit(j))
{
BitArray[footer] = 1 ;
}
else{
BitArray[footer] = 0 ;
}
footer++;
}
ptr_-- ;
}
}
char* GetMsbToLsb(int msb,int lsb,char *BitArray,int ByteLength)
{
//------------------------------------------------------------------------
// Function Introduce
// ------------------------
// malloc a new memory and store from lsb bit to msb bit of BitArray
// end at return the pointer of the new memory ,free it after use
//------------------------------------------------------------------------
char *storeptr; char* ptrout ;
storeptr = (char*)malloc(sizeof(char)*ByteLength); memset(storeptr,0,ByteLength);
ptrout = storeptr ;
storeptr +=sizeof(char)*(ByteLength-1);
int assignfooter = lsb-1;
while(assignfooter<msb)
{
for(int i=0;i<8;i++)
{
if(BitArray[assignfooter])
{
*storeptr |=Bit(i);
}
assignfooter++ ;
if(assignfooter>=msb || assignfooter >= (ByteLength*8))
{
return ptrout ;
}
}
if(assignfooter>=msb || assignfooter >= (ByteLength*8))
{
return ptrout ;
}
else{
storeptr-- ;
}
}
return ptrout ;
}Linux上获取绝对路径
char buf[200];memset(buf,0,200);
int count;
count = readlink( "/proc/self/exe", buf, MAXBUFSIZE );
if ( count < 0 || count >= MAXBUFSIZE )
{
printf( "Failed " );
return( EXIT_FAILURE );
}
printf( "path: %s\n", buf );
使用正则表达式方便获取配置项内容
char* GetConfigVal(const char* Path,const char* ConfigName)
{
//----------------------------------------------------------------------------
// Get config value
//---------------------------
// example:
// HrdacPort=808080
// HrdacAddr=192.168.1.1
// call GetConfigVal("configfilepath","HrdacPort");
// then 808080 will return as char ,you can use it as char or translate to others types
// Note:
// Free returned char after use
//----------------------------------------------------------------------------
string buf1;
string buf = (char*)ConfigName ; string in ; unsigned int Length=0 ;
buf.append("=[^\n ]*"); regex exp(buf);char* OutConfigVal ;
char* filebuf = Load_File_AtLength(Path,10000,&Length);
if(filebuf==NULL)
{
Fprint_String("!!FILE open ERROR\n","StdTrackError","a+");
exit(-1);
}
else{
in = filebuf ;
free(filebuf);
}
cmatch what;
if(regex_search(in.c_str(),what,exp))
{
//单字搜索，将每次匹配到的结果输出
printf("%s-end\n",what.base());
printf("%s-end\n",what[0].str().c_str());
in = what[0].str();
buf1=(char*)ConfigName; buf1.append("=(.*)");
regex expval(buf1); cmatch sub;
if(regex_match(in.c_str(),sub,expval))
{
OutConfigVal = (char*)malloc(sizeof(char)*sub[1].length()+1); memset(OutConfigVal,0,sub[1].length()+1);
memcpy(OutConfigVal,sub[1].str().c_str(),sub[1].length());
printf("%s-\n",OutConfigVal);
return OutConfigVal ;
}
}
return NULL;
}
其中函数
Load_File_AtLength(Path,10000,&Length);
#include <boost/regex.hpp>
#include <string.h>
#include <string.h>
#include <string>
using namespace std ;
using namespace boost;
using namespace std ;
using namespace boost;
使用上面函数需要包含入此头文件以及此名空间。
以上函数一般搭配使用下面检测函数：
void CheckGetConfigSuccess(const char *Message,const char *RecordFile,char *CheckPtr)
{
if(CheckPtr==NULL)
{
printf("%s",Message);
Fprint_String(Message,RecordFile,"a+");
exit(-1);
}
}
一般而言动态配置项不建议使用此函数，静态配置项推荐，因为他非常灵活，当然灵活同时，带来了不安全因素。
改进函数，放入到栈空间；并直接检测：
char* GetConfigVal(const char* Path,const char* ConfigName,char* OutConfigVal,const char *CheckMessage,const char *RecordFile)
{
//----------------------------------------------------------------------------
// Get config value
//---------------------------
// example:
// HrdacPort=808080
// HrdacAddr=192.168.1.1
// call GetConfigVal("configfilepath","HrdacPort");
// then 808080 will return as char ,you can use it as char or translate to others types
// Note:
// Free returned char after use
//----------------------------------------------------------------------------
string buf1;
string buf = (char*)ConfigName ; string in ; unsigned int Length=0 ;
buf.append("=[^\n ]*"); regex exp(buf);
char* filebuf = Load_File_AtLength(Path,10000,&Length);
if(filebuf==NULL)
{
Fprint_String("!!FILE open ERROR\n","StdTrackError","a+");
exit(-1);
}
else{
in = filebuf ;
free(filebuf);
}
cmatch what;
if(regex_search(in.c_str(),what,exp))
{
//单字搜索，将每次匹配到的结果输出
printf("%s-end\n",what.base());
printf("%s-end\n",what[0].str().c_str());
in = what[0].str();
buf1=(char*)ConfigName; buf1.append("=(.*)");
regex expval(buf1); cmatch sub;
if(regex_match(in.c_str(),sub,expval))
{
memset(OutConfigVal,0,sub[1].length()+1);
memcpy(OutConfigVal,sub[1].str().c_str(),sub[1].length());
printf("%s-\n",OutConfigVal);
return OutConfigVal ;
}
}
Fprint_String(CheckMessage,RecordFile,"a+");
return OutConfigVal;
}时间函数打印
char* GetLocalTime(char *timE)
{
time_t rawtime;
struct tm * timeinfo;
time ( &rawtime );
timeinfo = localtime ( &rawtime );
int len=strftime ( timE,80,"%F %T ",timeinfo);
timE[len]='\0';
return timE;
}变参用于字节拷贝
bool MemcpyByAddrAndLen(int ParaNum,...)
{
/*------------------------------------------------------------------------------------
* 变参函数内存操作
* 参数说明：
* int Para，void *ouput,void *Addr1,int len1,void *Addr2,int len2,......
* Addr is the enter of a mem
* len is the byte num of a mem
------------------------------------------------------------------------------------*/
char *output ; int ByteLengthCopyed = 0 ;
va_list pvar ;
va_start(pvar,ParaNum);
output=va_arg(pvar,char*);
for(int i=1;i<ParaNum;i+=2)
{
char *Addr = va_arg(pvar,char*);
int len = va_arg(pvar,int);
memcpy(output+sizeof(char)*ByteLengthCopyed,Addr,len);
ByteLengthCopyed+=len ;
}
va_end(pvar);
return 1 ;
}变参多标志检测查询等待
bool CheckFlagArr(bool **Arr,int ArrSize)
{
for(int i=0;i<ArrSize;i++)
{
if(!*Arr[i])
{
return 0 ;
}
}
return 1 ;
}
int HowMuchFlagSet(bool **Arr,int ArrSize)
{
int NumOfSet=0;
for(int i=0;i<ArrSize;i++)
{
if(*Arr[i]==1)
{
NumOfSet++ ;
}
}
return NumOfSet ;
}
void CLearFlagArr(bool **Arr,int ArrSize)
{
for(int i=0;i<ArrSize;i++)
{
*Arr[i]=0;
}
printf(" =。= %d Flags Clear\n",ArrSize);
}
bool BlockInquireFlags(int ParaNum,...)
{
/*------------------------------------------------------------
* 多参数标志检测，
* 参数： 参数总数，阻塞等待时间（单位：秒），标志，标志，标志，标志
------------------------------------------------------------*/
va_list pvar ; bool *FlagArr[ParaNum-1]; int WaitSec =0 ; int round =0 ; int alive_flag = 0;
va_start(pvar,ParaNum);
WaitSec = va_arg(pvar,int);
for(int i=1;i<ParaNum;i++)
{
FlagArr[i-1] = va_arg(pvar,bool*);
}
while(!CheckFlagArr(FlagArr,ParaNum-1))
{
usleep(100000); //100ms
round++;
alive_flag++ ;
if(alive_flag>10)
{
printf("%d secs waited %d flags is set\n",round/10,HowMuchFlagSet(FlagArr,ParaNum-1));
alive_flag=0 ;
}
if((round/10)>=WaitSec)
{
CLearFlagArr(FlagArr,ParaNum-1);
printf("!!!!!!!!!!!!!Block Wait TimeOut\n");
return 0 ;
break ;
}
}
printf(" ^_^ All Flags Set Done \n");
CLearFlagArr(FlagArr,ParaNum-1);
va_end(pvar);
return 1 ;
}
正则表达式匹配后，写指定文件位置
int ReplaceStr(char *sSrc, char *sMatchStr, char *sReplaceStr,int MaxStringLen)
{
int StringLen;
char caNewString[MaxStringLen];
char *FindPos = strstr(sSrc, sMatchStr);
if( (!FindPos) || (!sMatchStr) )
return -1;
while( FindPos )
{
memset(caNewString, 0, sizeof(caNewString));
StringLen = FindPos - sSrc;
strncpy(caNewString, sSrc, StringLen);
strcat(caNewString, sReplaceStr);
strcat(caNewString, FindPos + strlen(sMatchStr));
strcpy(sSrc, caNewString);
FindPos = strstr(sSrc, sMatchStr);
}
return 0;
}
char* GetConfigVal(const char* Path,const char* ConfigName,char* OutConfigVal,const char *CheckMessage,const char *RecordFile)
{
//----------------------------------------------------------------------------
// Get config value
//---------------------------
// example:
// HrdacPort=808080
// HrdacAddr=192.168.1.1
// call GetConfigVal("configfilepath","HrdacPort");
// then 808080 will return as char ,you can use it as char or translate to others types
// Note:
// Free returned char after use
//----------------------------------------------------------------------------
string buf1;
string buf = (char*)ConfigName ; string in ; unsigned int Length=0 ;
buf.append("=[^\n ]*"); regex exp(buf);
char* filebuf = Load_File_AtLength(Path,10000,&Length);
if(filebuf==NULL)
{
Fprint_String("!!FILE open ERROR\n","StdCmdCenterError","a+");
exit(-1);
}
else{
in = filebuf ;
free(filebuf);
}
cmatch what;
if(regex_search(in.c_str(),what,exp))
{
//单字搜索，将每次匹配到的结果输出
// printf("%s-end\n",what.base());
// printf("%s-end\n",what[0].str().c_str());
in = what[0].str();
buf1=(char*)ConfigName; buf1.append("=(.*)");
regex expval(buf1); cmatch sub;
if(regex_match(in.c_str(),sub,expval))
{
memset(OutConfigVal,0,sub[1].length()+1);
memcpy(OutConfigVal,sub[1].str().c_str(),sub[1].length());
printf("load config %s-\n",OutConfigVal);
return OutConfigVal ;
}
}
Fprint_String(CheckMessage,RecordFile,"a+");
return OutConfigVal;
}
char* WriteConfigVal(const char* Path,const char* ConfigName,const char* InConfigVal,const char *CheckMessage,const char *RecordFile)
{
//----------------------------------------------------------------------------
// Get config value
//---------------------------
// example:
// HrdacPort=808080
// HrdacAddr=192.168.1.1
// call GetConfigVal("configfilepath","HrdacPort");
// then 808080 will return as char ,you can use it as char or translate to others types
// Note:
// Free returned char after use
//----------------------------------------------------------------------------
string buf1;
string buf = (char*)ConfigName ; string in ; unsigned int Length=0 ;
buf.append("=[^\n ]*"); regex exp(buf);
char* filebuf = Load_File_AtLength(Path,10000,&Length);
if(filebuf==NULL)
{
Fprint_String("!!FILE open ERROR\n","StdCmdCenterError","a+");
exit(-1);
}
else{
in = filebuf ;
free(filebuf);
}
cmatch what;
if(regex_search(in.c_str(),what,exp))
{
//单字搜索，将每次匹配到的结果输出
// printf("%s-end\n",what.base());
// printf("%s-end\n",what[0].str().c_str());
int srcLen = strlen(what.base())+strlen(InConfigVal);
char src[srcLen]; memset(src,0,srcLen);
memcpy(src,what.base(),srcLen);
char srcmatch[100];
GetConfigVal(Path,ConfigName,srcmatch,CheckMessage,RecordFile);
if(!strcmp(srcmatch,(char*)InConfigVal))
return 0;
ReplaceStr(src,srcmatch,(char*)InConfigVal,srcLen);
Fprint_String(src,Path,"w+");
// printf("%s-end\n",src);
}
return (char*)InConfigVal;
}通过进程名寻找进程ID
void find_pid_by_name(const char* pidName,long* pidList)
{
#define READ_BUF_SIZE 50
DIR *dir;
struct dirent *next;
int i=0;
///proc中包括当前的进程信息,读取该目录
dir = opendir("/proc");
if (!dir)
printf("Cannot open /proc");
//遍历
while ((next = readdir(dir)) != NULL) {
FILE *status;
char filename[READ_BUF_SIZE];
char buffer[READ_BUF_SIZE];
char name[READ_BUF_SIZE];
/* Must skip ".." since that is outside /proc */
if (strcmp(next->d_name, "..") == 0)
continue;
/* If it isn't a number, we don't want it */
if (!isdigit(*next->d_name))
continue;
//设置进程
sprintf(filename, "/proc/%s/status", next->d_name);
if (! (status = fopen(filename, "r")) ) {
continue;
}
if (fgets(buffer, READ_BUF_SIZE-1, status) == NULL) {
fclose(status);
continue;
}
fclose(status);
//得到进程id
/* Buffer should contain a string like "Name: binary_name" */
sscanf(buffer, "%*s %s", name);
if (strcmp(name, pidName) == 0) {
pidList[i++]=strtol(next->d_name, NULL, 0);
}
}
if (pidList) {
pidList[i]=0;
}
}清除多余进程：
void ClearUncessaryProcess(long *pids,int size)
{
for(int i=0;i<size;i++)
{
if(pids[i]==0)
continue;
printf("KILLING PID:%ld\n",pids[i]);
kill(pids[i],SIGKILL);
}
}
void ClearUncessaryProcess(const char* ProcessName)
{
long reset_pids[20];
for(int i=0;i<20;i++)
reset_pids[i]=0;
find_pid_by_name(ProcessName,reset_pids);
ClearUncessaryProcess(reset_pids,20);
}BCD到16进制，十进制转换
#include <stdio.h>
#include <string.h>
/
//
//功能：二进制取反
//
//输入：const unsigned char *src 二进制数据
// int length 待转换的二进制数据长度
//
//输出：unsigned char *dst 取反后的二进制数据
//
//返回：0 success
//
//
int convert(unsigned char *dst, const unsigned char *src, int length)
{
int i;
for(i=0; i<length; i++)
{
dst[i] = src[i]^0xFF;
}
return 0;
}
//
//
//功能：十六进制转为十进制
//
//输入：const unsigned char *hex 待转换的十六进制数据
// int length 十六进制数据长度
//
//输出：
//
//返回：int rslt 转换后的十进制数据
//
//思路：十六进制每个字符位所表示的十进制数的范围是0 ~255，进制为256
// 左移8位(<<8)等价乘以256
//
/
unsigned long HextoDec(const unsigned char *hex, int length)
{
int i;
unsigned long rslt = 0;
for(i=0; i<length; i++)
{
rslt += (unsigned long)(hex[i])<<(8*(length-1-i));
}
return rslt;
}
/
//
//功能：十进制转十六进制
//
//输入：int dec 待转换的十进制数据
// int length 转换后的十六进制数据长度
//
//输出：unsigned char *hex 转换后的十六进制数据
//
//返回：0 success
//
//思路：原理同十六进制转十进制
//
int DectoHex(int dec, unsigned char *hex, int length)
{
int i;
for(i=length-1; i>=0; i--)
{
hex[i] = (dec%256)&0xFF;
dec /= 256;
}
return 0;
}
/
//
//功能：求权
//
//输入：int base 进制基数
// int times 权级数
//
//输出：
//
//返回：unsigned long 当前数据位的权
//
//
unsigned long power(int base, int times)
{
int i;
unsigned long rslt = 1;
for(i=0; i<times; i++)
rslt *= base;
return rslt;
}
/
//
//功能：BCD转10进制
//
//输入：const unsigned char *bcd 待转换的BCD码
// int length BCD码数据长度
//
//输出：
//
//返回：unsigned long 当前数据位的权
//
//思路：压缩BCD码一个字符所表示的十进制数据范围为0 ~ 99,进制为100
// 先求每个字符所表示的十进制值，然后乘以权
//
unsigned long BCDtoDec(const unsigned char *bcd, int length)
{
int i, tmp;
unsigned long dec = 0;
for(i=0; i<length; i++)
{
tmp = ((bcd[i]>>4)&0x0F)*10 + (bcd[i]&0x0F);
dec += tmp * power(100, length-1-i);
}
return dec;
}
/
//
//功能：十进制转BCD码
//
//输入：int Dec 待转换的十进制数据
// int length BCD码数据长度
//
//输出：unsigned char *Bcd 转换后的BCD码
//
//返回：0 success
//
//思路：原理同BCD码转十进制
//
//
int DectoBCD(int Dec, unsigned char *Bcd, int length)
{
int i;
int temp;
for(i=length-1; i>=0; i--)
{
temp = Dec%100;
Bcd[i] = ((temp/10)<<4) + ((temp%10) & 0x0F);
Dec /= 100;
}
return 0;
}
int main()
{
register int i;
unsigned char tmp_bff[12] = "";
//十六进制转十进制
unsigned char HEX[4] = {0x34, 0xFE, 0x3E, 0xFF};
unsigned long dec_hex = 0;
dec_hex = HextoDec(HEX, 4);
printf("dec_hex = %d/n", dec_hex);
//十进制转十六进制
DectoHex(dec_hex, tmp_bff, 4);
for(i=0; i<5; i++)
{
printf("tmp_bff[%d] = 0x%02X/n",i, tmp_bff[i]);
}
//BCD码转十进制
unsigned long dec_bcd = 0;
unsigned char BCD[4] = {0x98, 0x23, 0x45, 0x78};
dec_bcd = BCDtoDec(BCD, 4);
printf("dec_bcd = %d/n", dec_bcd);
//十进制转BCD码
DectoBCD(dec_bcd, tmp_bff, 4);
for(i=0; i<5; i++)
{
printf("tmp_bff[%d] = 0x%02X/n", i, tmp_bff[i]);
}
getchar();
}纯净C获取ＩＰ地址：
#include <stdio.h>;
#include <sys/types.h>;
#include <sys/socket.h>;
#include <sys/ioctl.h>;
#include <netinet/in.h>;
#include <net/if.h>;
#include <net/if_arp.h>;
#include <arpa/inet.h>;
#include <errno.h>;
#define ETH_NAME "eth0"
int main()
{
int sock;
struct sockaddr_in sin;
struct ifreq ifr;
sock = socket(AF_INET, SOCK_DGRAM, 0);
if (sock == -1)
{
perror("socket");
return -1;
}
strncpy(ifr.ifr_name, ETH_NAME, IFNAMSIZ);
ifr.ifr_name[IFNAMSIZ - 1] = 0;
if (ioctl(sock, SIOCGIFADDR, &ifr) < 0)
{
perror("ioctl");
return -1;
}
memcpy(&sin, &ifr.ifr_addr, sizeof(sin));
fprintf(stdout, "eth0: %s\n", inet_ntoa(sin.sin_addr));
return 0;
}
C++ Switch String:
#pragma once
// ----------------------------------------------------------------------------
// string_switch_case.h
//
// These macros together implement switch-case functionality for C strings and
// std::string. When first encountered, the switch-case structure does two
// passes. The first pass is a one-time initialization of a std::map with the
// strings as keys, and line numbers as values, to get the unique keys needed
// for a numeric switch-case. All subsequent passes use the std::map to
// retrieve an unsigned integer for a given string, that was mapped during the
// first pass, to use for a numeric switch case. This switch-case approach can
// be used repeatedly and even nested. An example of the usage is as follows:
//
// switch_string(a)
// {
// case_string("first string")
// printf("first string");
// break;
// case_string("second string")
// printf("second string");
// case_string("third string")
// printf("falls through to third string");
// break;
// default_case_string
// printf("default");
// }
// end_switch_string
//
// The end_switch_string macro is required after the closing brace of the
// switch-case structure. Each case_string statement must be on a unique line.
// Each case_string has its own local scope. A case_string statement is
// ignored if declared within scope brackets beneath a sibling case statement.
// ----------------------------------------------------------------------------
#include <map>
#include <string>
// switch macro
#define switch_string(a) while (true) { static std::map<std::string, unsigned int> _string_lookup_; static bool _init_ = true; unsigned int _val_ = 0; if (!_init_) { std::map<std::string, unsigned int>::iterator _iter_ = _string_lookup_.find(a); if (_iter_ != _string_lookup_.end()) { _val_ = (*_iter_).second; } else { _val_ = 0xffffffff; } } switch(_val_) { case 0:
// case macro
#define case_string(a) } case __LINE__: if (_init_) _string_lookup_.insert (std::pair<std::string, unsigned int>(a, __LINE__)); else {
// default case macro
#define default_case_string } default: if (!_init_) {
// required macro for the end of the switch-case
#define end_switch_string } if (_init_) { _init_ = false; } else { break; } }
扫一扫
6433
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
