CString/string /Char转化、Vector、分割、New、Malloc、Memset、Memcpy、Strcpy、static
2013-02-07 15:54
543 查看
#include "stdafx.h" #include <string> // #include <stdlib.h> #include <stdio.h> #include <iostream> using namespace std; int _tmain() { //把字符串转成数字 char *token="20";//或者 char token[10]="20"; int n; n=atoi(token); n+=8; //把数字转成字符串 char buf[200]; //不能转换成 char *buf; 可以写成char *buf=new char[200] sprintf_s(buf,20,"%d",n); cout<<buf; return 0; }
char *itoa(int value, char *string, int radix);
int value 被转换的整数,char *string 转换后储存的字符数组,int
radix 转换进制数,如2,8,10,16 进制等
char charUnsharp[10];
int num= 3;
itoa(num,charUnsharp,10);//把整数num转换成字符串charUnsharp ,10进制转换。
为TgImage自定义的结构体分配空间
static char* pShowImgX;
static TgImage outimage;//前面加了个static
if ( bFirstreg )
{
bFirstreg = FALSE;
pShowImgX = new char[384*288*3];
outimage.pData = pShowImgX;
outimage.width = g_Image.width;
outimage.height = g_Image.height;
outimage.nChannels = 3;
}
在用MFC进行编程时,我们从对话框中利用GetWindowText得到的字符串是 CString类型,CString是属于MFC的类。
而一些标准C/C++库函数是不能直接对CString类型进行操作的,所以我们经常遇到将 CString类型转化char*等等其他数据类型的情况。这里总结备忘于此!
首先要明确,标准C中是不存在string类型的,string是标准C++扩充字符串操作的一个类。但是我们知道标准C中有string.h这个头文件,这里要区分清楚,此string非彼string。 string.h这个头文件中定义了一些我们经常用到的操作字符串的函数,如:strcpy、strcat、strcmp等等,但是这些函数的操作对象都是char*指向的字符串。而C++的string类操作对象是string类型字符串,该类重装了一些运算符,添加了一些字符串操作成员函数,使得操作字符串更加方便。有的时候我们要将string串和char*串配合使用,所以也会涉及到这两个类型的转化问题。
CString并非是你赋予多大长度的字符串就占有多大的内存空间。它的空间分配机制是事先申请一个比较大的内存空间来存放字符串,在以后的操作中如果字符串超出了这个内存区域,它才会先释放原先的内存区域,重新申请一个更大的内存空间。同样,如果字符串变短了,它也不是立即释放多余空间,而是累积到了一定程度才释放。这样实现了“无长度限制”,又避免了频繁的申请、释放内存的操作。
CString的另外一个特色就是“写入复制技术(CopyBeforeWrite)”。当使用一个CString对象A来初始化另外一个CString对象B时,B并不会被分配空间,而是将自己的指针指向对象A的存储空间。除非对两个中的某个做修改时,才会为对象B申请内存。
1.CString和string的转化
string str="ksarea";
CString cstr(str.c_str());//或者CString cstr(str.data());初始化时才行
cstr = str.c_str();或者cstr = str.data();
str = cstr.GetBuffer(0); //CString -> string
cstr.format("%s", str.c_str());
//string->CString
cstr.format("%s", str.data()); //string->CString
str = LPCSTR(cstr); //CString->string
/*c_str()和data()区别是:前者返回带'/0'的字符串,后者则返回不带'/0'的字符串*/
string类型不能直接赋值给CString
2.CString和int的转换
int i=123;
CString str;
str.format("%d",i);//int->CString 其他的基本类型转化类似
i=atoi(str);//CString->int 还有(atof,atol)
3、判断string是否为空
string类为空,实际也就是元素为0个。 可以按照如下方式判断:1、string类有自己的成员函数empty, 可以用来判断是否为空。
3、string类型转换int类型
1、cstd::string str;
int i = atoi(str.c_str());
2、c++
std::string str;
int i = std::stoi(str);
3、从string中取某个字符
string stem="123456"
stem[2] 里面的值是字符3
int(stem[2])-'0' 得到数值3
string怎样判断字符串里面是否含有某个字符串
string::size_type string::find(string&);
1)
string a="abcdefghigklmn"; string b="def"; idx=a.find(b);//在a中查找b. if(idx == string::npos )//不存在。 cout << "not found\n"; else//存在。 cout <<"found\n";
2)C语言风格。字符串存储为字符数组,以'\0'结束。
在C的接口中,有strstr函数,可以在字符串中查找另一个字符串。
char * strstr(const char *str1, const char *str2);
功能为在str1中查找str2,如果存在,那么返回查找到的起始指针,否则返回NULL。
string中c_str()、data()、copy(p,n)函数的用法
标准库的string类提供了3个成员函数来从一个string得到c类型的字符数组:c_str()、data()、copy(p,n)。1. c_str():生成一个const char*指针,指向以空字符终止的数组。
注:
①这个数组的数据是临时的,当有一个改变这些数据的成员函数被调用后,其中的数据就会失效。因此要么现用先转换,要么把它的数据复制到用户自己可以管理的内存中。注意。看下例:
const char* c;
string s="1234"; c = s.c_str(); cout<<c<<endl;//输出:1234 s="abcd"; cout<<c<<endl;//输出:abcd
上面如果继续用c指针的话,导致的错误将是不可想象的。就如:1234变为abcd
其实上面的c = s.c_str(); 不是一个好习惯。既然c指针指向的内容容易失效,我们就应该按照上面的方法,那怎么把数据复制出来呢?这就要用到strcpy等函数(推荐)。
//const char* c; //① //char* c; //② //char c[20]; char* c=new char[20]; string s="1234"; //c = s.c_str(); strcpy(c,s.c_str()); cout<<c<<endl;//输出:1234 s="abcd"; cout<<c<<endl;//输出:1234
注意:不能再像上面一样①所示了,const还怎么向里面写入值啊;也不能②所示,使用了未初始化的局部变量“c”,运行会出错的 。
② c_str()返回一个客户程序可读不可改的指向字符数组的指针,不需要手动释放或删除这个指针。
2. data():与c_str()类似,但是返回的数组不以空字符终止。
3. copy(p,n,size_type _Off = 0):从string类型对象中至多复制n个字符到字符指针p指向的空间中。默认从首字符开始,但是也可以指定,开始的位置(记住从0开始)。返回真正从对象中复制的字符。------用户要确保p指向的空间足够保存n个字符。
string::copy()举例:
char c2[11] = {0};
string s2 = "hello boy!";
int iRtn = s2.copy(c2, 10, 0);//功能为将s2的,从第0个开始的,共10个字符拷贝到c2中,iRtn为拷贝的字符个数,此处为10。
注意:iRtn返回的是实际拷贝的字节数,当第二个参数比字符串本身长时,返回的便是字符串长度。
MFC问题int转cstring
CString msg; int dep = disp.depth();
msg.Format(_T("depth:%d"),dep);
AfxMessageBox(msg);
3. char* 和CString的转换
1) CString cstr = "ksarea";
char* ptemp = cstr.getbuffer(0);
2) char* str;
strcpy(str,ptemp);//CString->char*
cstr.releasebuffer(-1);
char* str="lovesha";
CString cstr=str;//char*->CString
至于int与float、string与char*之间的转化可以使用强制转化,或者标准库函数进行。对于CString与其他类型的转化方法很多,但其实都殊途同归,朝着一个方向即将类型首先转化为char*类型,因为char*是不同类型之间的桥梁。得到char*类型,转化为其他类型就非常容易了。
3.1 把两个char *字符串复制到另一个char * 变量中
char str3[20];
strcpy(str3,str1);
strcat(str3,str2);
char* str=str3;
cout<<str<<endl; //使用此句要包含:#include <iostream> 和 using namespace std;
string 转换成 const char *
string s1 = "abcdeg";
const char *k = s1.c_str();或 const char *t = s1.data();
printf("%s%s",k,t);
cout<<k<<t<<endl;
如上,都可以输出。内容是一样的。但是只能转换成const char*,如果去掉const编译不能通过。
那么,如果要转换成char*,可以用string的一个成员函数copy实现。
string s1 = "abcdefg";
char *data;
int len = s1.length();
data = (char *)malloc((len+1)*sizeof(char));
s1.copy(data,len,0);
printf("%s",data);
cout<<data; //说明,如果字符集是unicode的话,可能字符串后面有乱码,如果选 为多字符集的话,就只输出字符串
3.2、char *转换成string
可以直接赋值。
string s;
char *p = "adghrtyh";
s = p;
printf("%s",s1.c_str())// 这样是正确的
// printf("%s",s1) 这样是错误的
cout<<s.c_str()<<endl; //正确
//cout<<s<<endl; //错误
注:
1)用printf("%s",s1);输出是会出问题的。这是因为“%s”要求后面的对象的首地址。但是string不是这样的一个类型。所以肯定出错。
那么可以这样:printf("%s",s1.c_str())
如何判断一个 char * s 指针的内容是否为空
1、 CString strname;
strname=m_bstr_name; //m_bstr_name也是CString类型的
if (strname=="")
{
AfxMessageBox("name is null");
}
如果要判断一个char *s 是否为空,要用strcmp(m_bstr_name.GetBuffer(0),"")进行判断
2、if (strcmp(m_bstr_name.GetBuffer(0),"")==0) //m_bstr_name.GetBuffer(0)是把一个CString类型转换成char *类型
{
AfxMessageBox("name is null");
}
else
AfxMessageBox("name is not null222");
(2) char * s = new char[10];
memset(s,'\0',10);
if(strcmp(s,"")==0) 或者是 if(s[0]==0)
注意:如果写成下面这样,就是错误的
if (m_bstr_name.GetBuffer(0) ==“”) //m_bstr_name.GetBuffer(0)是把一个CString类型转换成char *类型
上面这句是错误,m_bstr_name.GetBuffer(0)指向的内容一直都不是空。
String name==null;//是空引用 Null ::一个值,表示一个变量不包含任何有效数据。
String name="";//这是个空字符串
String name="";这个在堆上分配了储存空间.你可以调用String的所有方法.
第一个只是空引用.不能在第一个上调用String的任何方法.因为他是一个空引用. 空字符串也是串.
3、两个char * 字符串的比较
char* str_1 = "abc" ; char * str_2 = "abc" ; char* str_3 = "ABC" ;
if (strcmp(str_1, str_2) == 0)
{ 。。。。。
}
error C2501: 'string' : missing storage-class
or type specifiers
1.首先正确包含头文件
使用下面语句
#include <string>
没有.h,
否则无法引用标准模板库
2.使用命名空间
即使用下面语句:
using namespace std;
3.string 所创建的对象不能够直接使用里面的字符串
如 string str;
cout<<str<<endl;
这样语句不能执行
要使用string的一个函数进行转化 c_str() 才能正确使用其中的字符串。
4、怎样比较两个类型为String的字符串?
1)string s1="fsf";
string s2="sdfnk";
// if(strcmp(s1,s2))//这样写错误,因为strcmp(s1,s2)中,要求s1,s2都是char * 类型
if (s1.compare(s2)==0) // 这样写正确
cout<<"s1 is equal to s2";
else
cout<<"s1 !=s2";
2)
string s1="fsf";
string s2="fsf";
// if(strcmp(s1,s2))//这样写错误,因为strcmp(s1,s2)中,要求s1,s2都是char * 类型
// if (s1.compare(s2)==0)//正确
if (s2 ==s1) //正确
cout<<"s1 equal to s2"<<endl;
else
cout<<"s1 is not s2"<<endl;
说明:如果内容已经存在了,不会分配第二个,上面已经 String s1 = "fsf";了, 这个"fsf"已经存在了,下面String s2 = "fsf"; 就不会分配第二个"fsf"了,那么s2指向谁?s2也指向上面s1指向的这个对象,现在是s1和s2同时指向同一个对象,那么它们的地址当然一样,==比较的是引用地址,所以s1 == s2
返回true。
在两个对象之间使用 "==",会将“两个对象是否有同一reference”的结果传回。也就是说, 这等同于“两个对象是否拥有同一地址 (address)”,或者“两个对象物件是否为同一对象”。
如果您的意思是判断两个字符串的内容是否相同,那么应该使用以下的方法才对:
if (s1.equals(s2) )
or if (s1.equalsIgnoreCase(s2) )
or if (s1.startsWith(s2) )
or if (s1.endsWith(s2) )
or if (s1.regionMatches(s1_offset, s2, s2_offset, length) )
or if (s1.compare(s2) )
1)strlen:计算字符串s的长度,不包括'\0'在内 //const char * 的长度
如:
string strName="abc";
char * data="bcd";
int len2=strlen(strName);//错误 要求:strName 为const char* 类型
int len2=strlen(data);//正确
cout<<"len2: "<<len2<<endl; 结果是len2: 3
2)sizeof:判断数据类型长度符
如:sizeof(int)结果就是4,
sizeof(string)结果就是16,
sizeof(char *)结果就是4,
sizeof(char)结果就是1
3)length:是求字符串长度,或数组中长度最长的那一维的长度。
如: string strName="abc"; int len = strName.length();//string 的长度 cout<<"len: "<<len<<endl; 结果就是 len: 3
总之:strlen是统计字符串的字符个数,不包括结尾的\0;length是求字符串长度,
5、转换成相应的字符串
vs2005:
char *filename=new char[20];
sprintf_s(filename,20,"air%d.jpg",i);
vc6.0:
char *filename=new char[20];
sprintf(filename,"air%d.jpg",i);
char buf[5];
sprintf(buf,"%d",srcImg->nChannels);
MessageBox(buf);
CString cstr;
cstr.format("%s", 123);
IplImage* paintx=cvCreateImage( cvGetSize(src),IPL_DEPTH_8U, 1 );
IplImage* painty=cvCreateImage( cvGetSize(src),IPL_DEPTH_8U, 1 );
// cvZero(paintx); //全变为黑色
cvSet(paintx,cvScalar(255,255,255,255),0);//全变为白色
cvZero(painty);
int* v=new int[src->width];
int* h=new int[src->height];
memset(v,0,src->width*4);
memset(h,0,src->height*4);
delete v;
delete h;
CString str1;
avg=totalwidthmy/(w.size()-6-sb);
str1.Format("%d",avg);
MessageBox(str1);
6、new 和 malloc 的区别
从函数声明上可以看出。malloc 和 new 至少有两个不同: new 返回指定类型的指针,并且可以自动计算所需要大小。比如:
int *p; p = new int; //返回类型为int* 类型(整数型指针),分配大小为 sizeof(int);
或:
int* parr; parr = new int [100]; //返回类型为 int* 类型(整数型指针),分配大小为 sizeof(int) * 100;
而 malloc 则必须要由我们计算字节数,并且在返回后强行转换为实际类型的指针。
int* p; p = (int *) malloc (sizeof(int)*128); //分配128个(可根据实际需要替换该数值)整型存储单元,并将这128个连续的整型存储单元的首地址存储到指针变量p中 double *pd=(double *) malloc (sizeof(double)*12); //分配12个double型存储单元, //并将首地址存储到指针变量pd中
第一、malloc 函数返回的是 void * 类型。对于C++,如果你写成:p = malloc (sizeof(int)); 则程序无法通过编译,报错:“不能将 void* 赋值给 int * 类型变量”。所以必须通过 (int *) 来将强制转换。而对于C,没有这个要求,但为了使C程序更方便的移植到C++中来,建议养成强制转换的习惯。
第二、函数的实参为 sizeof(int) ,用于指明一个整型数据需要的大小。如果你写成:
int* p = (int *) malloc (1);
代码也能通过编译,但事实上只分配了1个字节大小的内存空间,当你往里头存入一个整数,就会有3个字节无家可归,而直接“住进邻居家”!造成的结果是后面的内存中原有数据内容被改写。
7、 memset()、memcpy()、strcpy()、strncpy()
1)memset()的深刻内涵:用来对一段内存空间全部设置为某个字符,一般用在对定义的字符串进行初始化为‘ ’或‘\0’;
例:char a[100];
memset(a, '\0', sizeof(a)*100);
1,第一个程序为什么可以,而第二个不行?
因为第一个程序的数组a是字符型的,字符型占据内存大小是1Byte,而memset函数也是以字节为单位进行赋值的,所以你输出没有问题。
而第二个程序a是整型的,使用 memset还是按字节赋值,这样赋值完以后,每个数组元素的值实际上是0x01010101即十进制的16843009。
如果用memset(a,1,20) 就是对a指向的内存的20个字节进行赋值,每个都用ASCⅡ为1的字符去填充,转为二进制后,1就是00000001,占一个字节。一个INT元素是4字节,合一起就是0x01010101,就等于16843009,就完成了对一个int 元素的赋值了
2)memcpy用来做内存拷贝,你可以拿它拷贝任何数据类型的对象,可以指定拷贝的数据长度;
例:char a[100],b[50];
memcpy(b, a, sizeof(b));注意如用sizeof(a),会造成b的内存地址溢出。把a的前sizeof(b)个字符复制到b中
3)strcpy就只能拷贝字符串了,它遇到'/0'就结束拷贝;
例:char a[100], b[50];
strcpy(a,b); 如用strcpy(b,a),要注意a中的字符串长度(第一个‘/0’之前)是否超过50位,如超过,则会造成b的内存地址溢出。
4) strcpy 和strncpy 的差别在哪里,各自的优缺点是什么
strcpy (目标串地址,源串的开始地址): 从源串的开始到结尾('\0')完全拷贝到目标串地址 strncpy(目标串地址,源串的开始地址,n): 从源串的开始拷贝n个字符到目标串地址,n大于源串长度时,遇到'\0'结束; n小于源串长度时,到第n个字符结束,但不会在目标串尾补'\0'
char *p="hello";
char *p1="liulina";
char s[40]="how are you? where are you from";
strncpy(s,p1,3);
cout<<s<<endl;// 输出 liu are you? where are you from
strcpy(s,p);//输出 hello
cout<<s<<endl;
8、动态分配数组大小
typedef std::vector<int> List;
List w;
w.push_back(roi.width);
w.size();//容器里有多少个变量
用new分配的对象会调用对象的构造函数,delete则会调用对象的析构函数
而malloc和free从不调用构造和析构函数,他们只是简单的分配内存。
参考以下程序分析说明 new 和 malloc 的区别: 1#include <iostream> 2#include <cstdio> 3#include <cstdlib> 4using namespace std; 5class T 6{ 7 public: 8 T(){ cout << "T()" << endl; } 9 ~T(){ cout << "~T()" << endl; } 10 }; 11int main() 12{ 13 T* first = new T; 14 T* second = (T*)malloc(sizeof(T)); 15 if( first ) delete first; 16 if( second ) free(second); 17 return 0; 18} 解答: 由第13、14行代码可见,new,malloc均能完成动态分配一个新的空间的功能,并把它的首地址交给一个指针。区别在于: 1. new直接写在类型T的前面,是C++中的一个操作符,且直接分配T大小的内存空间。而malloc是C中的一个函数,且需要借助于函数sizeof帮其判断T类型的大小; 2. new直接返回一个T类型的指针,而且会调用类中的构造函数。而malloc返回一个void指针,需要在前面对其强制定义为一个T类型的指针,不用调用构造函数。 3. new与delete搭配使用,delete会调用类中的析构函数对内存进行释放。malloc则与free搭配,不调用析构函数。
9、 vetor容器
#include "stdafx.h" #include "cv.h" #include "highgui.h" #include "cvaux.h" #include "cxcore.h" #include <stdio.h> #include <vector> #include <iostream> #include <cv.h> #include <highgui.h> #pragma comment( lib, "cv.lib" ) #pragma comment( lib, "cxcore.lib" ) #pragma comment( lib, "highgui.lib" ) using namespace std; typedef std::vector<int> List; void bubble_sort(List& a,int n) { for(int i = 0; i < n; ++i)//[0..(n-1)] { //j < n - 1可以优化 for( int j = 0 ; j < n - 1; ++j)//a[0..(n-2)] if ( a[j] > a[j+1] ) { int t = a[j]; a[j] = a[j+1]; a[j+1] = t; } } } void print(List& a, int n) { for(int i = 0; i < n; ++i) { printf("%2d ",a[i]); } printf("\n"); } int main() { IplImage * src1=cvLoadImage("show1.bmp",0); IplImage * src=cvCreateImage(cvSize(src1->width,src1->height),src1->depth,src1->nChannels); cvErode(src1,src,NULL,1);//膨胀图像 cvSaveImage("c:\\src11.bmp",src); cvDilate(src,src,NULL,1);//腐蚀图像 cvSaveImage("c:\\src00.bmp",src); cvThreshold(src,src,150,255,/*CV_THRESH_BINARY_INV*/0); IplImage* paintx=cvCreateImage( cvGetSize(src),IPL_DEPTH_8U, 1 ); IplImage* painty=cvCreateImage( cvGetSize(src),IPL_DEPTH_8U, 1 ); // cvZero(paintx); //全变为黑色 cvSet(paintx,cvScalar(255,255,255,255),0);//全变为白色 cvZero(painty); int* v=new int[src->width]; int* h=new int[src->height]; memset(v,0,src->width*4); memset(h,0,src->height*4); int x,y; int mark=0,num1=0; int min=src->height,col=0; bool flag1=0; bool flag2=0; int leftnew=0,rightnew=0,left,right; CvScalar s,t; IplImage * histgram; char * fname=new char[100]; int temp[500][500]; int temp_cut[500];//分割出来的数字的宽度 int start_index[100];//从此位置开始分割 int temp_j1 = 0; int N=20; List w; // FIXEME: //垂直 for(x=0;x<src->width;x++) { mark=0; for(y=0;y<src->height;y++) { s=cvGet2D(src,y,x); if(s.val[0]==0) { v[x]++;//一列的黑点个数 mark++; } } //以下是分割,针对白底黑字的进行分割 if( flag1 == 0 ) { if(v[x]!= 0) { flag2 = 1; } } else { if(v[x] ==0) { flag2 = 1; } else { flag2 = 0; // break; } } if (x==src->width-1 && flag2==0) { flag2=1; } if( flag1 == 0 && flag2 == 1 ) { leftnew = x;//leftnew表示从此位置开始分割 start_index[num1] = x;//某个数字开始分割的起始位置 flag1 = 1; flag2 = 0; } if( flag1 == 1 && flag2 == 1) { rightnew=x; flag1 = flag2 = 0; //取字符 CvRect roi; roi.x=leftnew; roi.y=0; roi.width=rightnew-leftnew+1; roi.height=src->height; sprintf(fname,"%d.bmp",num1); cvSetImageROI(src,roi); cvSaveImage(fname,src); cvResetImageROI(src); //w[num1]=roi.width; num1++; w.push_back(roi.width); } } bubble_sort(w, w.size());//排序 print(w, w.size()); int sb=0; int total=0,avg=0; for (int i=3;i<w.size()-3;i++) { if (w[i]<30) { total+=w[i]; } else sb++;//统计宽度大于30的字符个数,不计入总宽度 } avg=total/(w.size()-6-sb); cout<<avg<<endl; for(x=0;x<src->width;x++) { for(y=0;y<v[x];y++) { t.val[0]=0; cvSet2D(paintx,(src->height-y-1),x,t); } } cvSaveImage("paintx.bmp",paintx); cvNamedWindow("二值图像",1); cvNamedWindow("垂直积分投影",1); cvShowImage("二值图像",src); cvShowImage("垂直积分投影",paintx); cvWaitKey(0); cvDestroyAllWindows(); cvReleaseImage(&src); cvReleaseImage(&paintx); cvReleaseImage(&painty); return 0; }
10、static的作用
在C语言中,static的字面意思很容易把我们导入歧途,其实它的作用有三条。
(1)先来介绍它的第一条也是最重要的一条:隐藏。
当我们同时编译多个文件时,所有未加static前缀的全局变量和函数都具有全局可见性。为理解这句话,我举例来说明。我们要同时编译两个源文件,一个是a.c,另一个是main.c。
下面是a.c的内容
char a = 'A'; // global variable
void msg()
{
printf("Hello\n");
}
下面是main.c的内容
int main(void)
{
extern char a; // extern variable must be declared before use
printf("%c ", a);
(void)msg();
return 0;
}
程序的运行结果是:
A Hello
你可能会问:为什么在a.c中定义的全局变量a和函数msg能在main.c中使用?前面说过,所有未加static前缀的全局变量和函数都具有全局可见性,其它的源文件也能访问。此例中,a是全局变量,msg是函数,并且都没有加static前缀,因此对于另外的源文件main.c是可见的。
如果加了static,就会对其它源文件隐藏。例如在a和msg的定义前加上static,main.c就看不到它们了。利用这一特性可以在不同的文件中定义同名函数和同名变量,而不必担心命名冲突。Static可以用作函数和变量的前缀,对于函数来讲,static的作用仅限于隐藏,而对于变量,static还有下面两个作用。
(2)static的第二个作用是保持变量内容的持久。存储在静态数据区的变量会在程序刚开始运行时就完成初始化,也是唯一的一次初始化。共有两种变量存储在静态存储区:全局变量和static变量,只不过和全局变量比起来,static可以控制变量的可见范围,说到底static还是用来隐藏的。虽然这种用法不常见,但我还是举一个例子。
#include <stdio.h>
int fun(void){
static int count = 10; // 事实上此赋值语句从来没有执行过
return count--;
}
int count = 1;
int main(void)
{
printf("global\t\tlocal static\n");
for(; count <= 10; ++count)
printf("%d\t\t%d\n", count, fun());
return 0;
}
程序的运行结果是:
global local static
1 10
2 9
3 8
4 7
5 6
6 5
7 4
8 3
9 2
10 1
(3)static的第三个作用是默认初始化为0。其实全局变量也具备这一属性,因为全局变量也存储在静态数据区。在静态数据区,内存中所有的字节默认值都是0x00,某些时候这一特点可以减少程序员的工作量。比如初始化一个稀疏矩阵,我们可以一个一个地把所有元素都置0,然后把不是0的几个元素赋值。如果定义成静态的,就省去了一开始置0的操作。再比如要把一个字符数组当字符串来用,但又觉得每次在字符数组末尾加’\0’太麻烦。如果把字符串定义成静态的,就省去了这个麻烦,因为那里本来就是’\0’。不妨做个小实验验证一下。
#include <stdio.h>
int a;
int main(void)
{
int i;
static char str[10];
printf("integer: %d; string: (begin)%s(end)", a, str);
return 0;
}
程序的运行结果如下 :
integer: 0; string: (begin)(end)
(4)在公用类中定义全局变量和全局函数,均使用static修饰,静态变量还必须在类外定义和初始化
Public.h:(公用类头文件)
class CPublic
{
public:
CPublic();
virtual ~CPublic();
public:
static int x; //全局变量
static int time; //全局变量
static int f(int y); //全局函数
…………
}
在公用类中对静态变量进行初始化和定义函数体:
Public.cpp:(公用类程序文件)(注意:下面的初始化)
int CPublic::x = 0; //初始化全局变量
int CPublic::time; //定义全局变量
CPublic::CPublic()
{
}
CPublic::~CPublic()
{
}
int CPublic::f(int y)
//全局函数,这里不要再加static
{
y++;
return y;
}
4、全局量的使用
使用变量:CPublic::变量名
使用函数:CPublic::函数()
如在视图的某函数中访问变量x和函数f():
void CTestView::xyz()
{
CPublic::x = 0; //访问变量x
CPublic::time = CPublic::f(1); //访问函数f()
…………
}
最后对static的三条作用做一句话总结:
1)首先static的最主要功能是隐藏
2)其次因为static变量存放在静态存储区,所以它具备持久性和默认值0。
返回字符串本身都是一件很危险的事情,
实在没想到,没有多少人回答这个问题。
1. 普遍情况下,使用VC6,一定不要返回string, CString.
string function() {}
这种应该杜绝,
在VC7和以后的版本中,是没有问题的,源于Allocator的实现问题。
也就是CRT的堆分配内存的问题。
2. 一般用法,
BSTR function(){}
char* function(){}
这种可以,
但是你的模块,最好提供一个响应的Release函数。
Release(BSTR);
Release(char*);
3. 推荐做法:
int function(char* ret, int buffer_size); // return string length.
function(string& ret);
只取图片名称或只取不带扩展名的图片名称
void CImgIncreaceDlg::OnBnClickedButOpenimg() { // TODO: 在此添加控件通知处理程序代码 CFileDialog fileDlg(TRUE, _T("*.bmp"), "", OFN_FILEMUSTEXIST|OFN_PATHMUSTEXIST|OFN_HIDEREADONLY, "Image Files (*.jpg; *.bmp)|*.jpg; *.bmp|All Files (*.*)|*.*||", NULL); //设置打开对话框的标题 char title[]= {"打开图片"}; fileDlg.m_pOFN->lpstrTitle= title; if(fileDlg.DoModal()==IDOK) { CString pathName= fileDlg.GetPathName();//C:\Pictures\doudou.bmp m_openPath= pathName; int i=m_openPath.ReverseFind('\\'); CString fn= m_openPath.Right(m_openPath.GetLength()-i-1);//此时fn = doudou.bmp int j=fn.ReverseFind('.');//从左往右的最后一个. 返回值为字符的索引 fn = fn.Left(j);//此时fn =doudou // MessageBox(fn); UpdateData(FALSE); // IplImage *srcImg = cvLoadImage(m_openPath); //cvNamedWindow(pathName,1); //cvShowImage(pathName,srcImg); int numUnsharp,numIncreace,numconstrast; char charUnsharp[10],charIncreace[10],charConstrast[10]; GetDlgItem(IDC_EDIT1_UNSHARP)->GetWindowText(charUnsharp,10); GetDlgItem(IDC_EDIT2_INCREACE)->GetWindowText(charIncreace,10); GetDlgItem(IDC_EDIT_CONSTAST)->GetWindowText(charConstrast,10); numUnsharp = atoi(charUnsharp); numIncreace = atoi(charIncreace); numconstrast = atoi(charConstrast); char *str= fn.GetBuffer(0); char filename[200]; CxImage cimg; cimg.Load(m_openPath,CXIMAGE_SUPPORT_BMP); if (cimg.IsValid()) { cimg.Light(numIncreace,numconstrast);//图像亮度增强,numIncreace>0,调亮,numIncreace<0,调暗,numconstrast是对比度 //cimg.Light(20,50); for (int i=0;i<numUnsharp;i++)//numUnsharp=3 { cimg.UnsharpMask(5.0,0.5,0);//锐化 } strcat(str,charUnsharp); strcat(str,"_"); strcat(str,charIncreace); strcat(str,"_"); strcat(str,charConstrast); strcat(str,".bmp"); strcpy(filename,str); cimg.Save(filename,CXIMAGE_FORMAT_BMP); } } }
char *itoa(int value, char *string, int radix);
int value 被转换的整数,char *string 转换后储存的字符数组,int
radix 转换进制数,如2,8,10,16 进制等
相关文章推荐
- CString/string char 区别及其转化
- CString string char * int double float 之间转化大全
- 【转】wchar_t*,wchar_t,wchat_t数组,char,char*,char数组,std::string,std::wstring,CString....相互之间的转化
- CString/string/char 的区别及转化
- CString/string/char*/char[]/int/float相互转化
- MFC中cstring,string和char[]的相互转化
- string,CString,char*之间的转化
- string CString char* wchar_t* 转化
- CString char* String 之间的转化
- String,CString,TCHAR,char间区别和联系以及相互转化 【转】
- CString,string,char*之间的转化(内部的?)
- CString、string、char*之间的转化
- string,CString,char*之间的转化
- CString/string/char*/char[]/int/float相互转化
- MFC中cstring,string和char[]的相互转化
- memcpy(void*,void*,unsigned int),memset(void*,char,unsigned int),strcpy(char*,char*)
- c++如何将vector<char>转化成string
- memset ,memcpy 和strcpy 的根本区别"#include "string.h""
- C++之char*,char[],string,CString,数字等互相转化
- string,CString,char*之间的转化