CString/string /Char转化、Vector、分割、New、Malloc、Memset、Memcpy、Strcpy、static

#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)

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的任何方法.因为他是一个空引用.    空字符串也是串.

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);

 

#include<iostream>

#include<cstring>

using namespace std;

int main()

{

char a[5];

memset(a,'1',5*sizeof(a)）;//sizeof(a) =1

for(int i=0;i<5;i++)

   cout<<a[i]<<"";

system("pause");

return0;

}

以上这段程序是正确的，a[i]的值是1.

 

#include<iostream>

#include<cstring>

#include<windows.h>

using namespace std;

int main()

{

int a[5];

memset(a,1,20）;//如果这里改成memset(a,1,5*sizeof(int))也不可以，因为memset按字节赋值。

for(int i=0;i<5;i++)

   cout<<a[i]<<" ";

system("pause");

return0;

}

问题是：

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 T6{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];}elsesb++;//统计宽度大于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.bmpm_openPath= pathName;int i=m_openPath.ReverseFind('\\');CString fn= m_openPath.Right(m_openPath.GetLength()-i-1);//此时fn = doudou.bmpint 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 进制等