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)

3、判断string是否为空

string类为空，实际也就是元素为0个。 可以按照如下方式判断：

1、string类有自己的成员函数empty, 可以用来判断是否为空。
2、判断字符串长度。如果长度为0，则为空。
3、与空串比较，如果相等则为空。
几种方法中，empty函数是效率最高也是最常用的一种。 

3、string类型转换int类型

1、c

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

 

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

 

问题是：

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 进制等