在线播放亚洲,亚洲免费在线观看,欧美va亚洲va日韩∨a综合色

最��单的windows�E�序

Wed, 23 Jul 2008 09:01:00 GMT

1.打开vc++;
2.选择菜单栏file----new�Q?br>3.选项卡选择Projects�Q?br>4.模板选择 Win32 Application;
5.输入Project name�Q?br>6.Loction 选择路径�Q?br>7.点击OK�l�箋�Q?br>8.选择默认�?#8220;An Empty project”�Q?br>9.点击finish完成创徏工程�Q?br>10.向工�E�里面添加一个c++文�g�Q�（file--new--选项卡file--C++ source file--输入文�g�?-点击OK�Q?br>11.输入以下代码�Q?/p>

#define WIN32_LEAN_AND_MEAN

#include<windows.h>
#include<windowsx.h>

int WINAPI WinMain(HINSTANCE hinstance,HINSTANCE hprevinstance,LPSTR lpcmdline,int ncmdshow)
{
MessageBox(NULL,"Hello World!","first win",MB_OK|MB_ICONEXCLAMATION);
return 0;
}

12.保存�Q�按ctrl+F5�~�译�q�运行�?br>13.弹出一个对话框�?br>

以上��是��L��世界上最��单的Windows�E�序�Q?br>

刘加�?/a> 2008-07-23 17:01 发表评论

函数�q�回值的�Ҏ(gu��)��情况�Q�返回引用、非引用、引用左��|��

Tue, 15 Jul 2008 16:41:00 GMT

�q�回非引�?/span>

      string make_plural(size_t i,const string &word,const string &ending)
      {
             return (i==1)?word:word+ending;
      }

      以上函数�Q�当i�{�于1�Ӟ��函数�q�回word形参的副本；当i不等�?时函数返回一个��时的string对象�Q�这个��时对象是由字�W�串word和ending相加而成的。这两种情况下，return都在调用该函数的地方防复制了�q�回的string对象�?br>
�q�回引用

      const string &shorterString(const string &s1,const string &s2)
      {
             return s1.size()      }

      以上函数的返回值是引用�c�d��。无��回s1或是s2,调用函数和返回结果时�Q�都没有复制�q�些string对象�?br>
千万不要�q�回局部对象的引用

      const string &mainip(const string &s)
      {
             string ret=s;
             return ret;
      }

      当函数执行完毕，�E�序��释攑ֈ�配给局部对象的存储�I�间。此�Ӟ��对局部对象的引用��׃��指向不确定的内存。（我在dev c++里运行通过。。。�?但是vc6和vc2008不能�~�译通过�Q�。同理，也不能返回局部对象的指针�?br>

引用�q�回左��|��比较奇妙�Q?/strong>

      char &get_val(string &str,string::size_type ix)
      {
             return str[ix];
      }

      使用语句调用:
       string s("123456");
       cout<       get_val(s,0)='a';
       cout<      把函数应用于左��|��q�是�W�一�ơ见刎ͼ�真是孤陋寡闻�Q��?br>
以下是上面几�U�情�늚�实例代码�Q?br>

//liujiajia
//2008-7-16
#include<iostream>
using namespace std;
string make_plural(size_t,const string&,const string&);
const string &shorterString(const string &,const string &);
const string &mainip(const string&);
char &get_val(string &,string::size_type);
int main(void)
{
    cout<<make_plural(1,"dog","s")<<endl;
    cout<<make_plural(2,"dog","s")<<endl;

    string string1="1234";
    string string2="abc";
    cout<<shorterString(string1,string2)<<endl;

    cout<<mainip("jiajia")<<endl;


    string s("123456");
    cout<<s<<endl;
    get_val(s,0)='a';

    cout<<s<<endl;

    getchar();
    return 0;
}
//�q�回非引�?nbsp;
string make_plural(size_t i,const string &word,const string &ending)
{
    return (i==1)?word:word+ending;
}
//�q�回引用
const string &shorterString(const string &s1,const string &s2)
{
    return s1.size()<s2.size()?s1:s2;
}
//��止�q�回局部对象的引用�Q�我的dev c++ 没有报错�Q�比较可怕）
const string &mainip(const string &s)
{
    string ret=s;
    return ret;
}
//引用�q�回左��|��W�一�ơ听��_��
char &get_val(string &str,string::size_type ix)
{
    return str[ix];
}

刘加�?/a> 2008-07-16 00:41 发表评论

Mon, 14 Jul 2008 16:05:00 GMT
      数组有两个特�D�的性质�Q�媄响我们定义和使用作用在数�l�上的函敎ͼ�一是不能复制数�l�。二是��用数�l�名字时�Q�数�l�会自动转换为指向其�W�一个元素的指针。因为数�l�不能复�Ӟ��所以无法编写��用数�l�类型�Ş参的函数。因为数�l�会被初始化为指针，所以处理数�l�的函数通常通过操作指向数组中的元素的指针来处理数组�?br>
�C�Z��Q?br>
      //形式1
      void printValues(const int ia[10])     //虽然形参指定了数�l�的大小�Q�但�~�译时不会检查实参数�l�大��，因�ؓ�~�译器只��查�Ş参是否是指针�Q��ƈ且指针类型和数组元素的类型是否匹配�?br>      {
             for(size_t i=0;i!=10;i++)
             {
                    cout<             }
      }
      //形式2
      void printValues2(const int ia[],int size)
      {
             for(size_t i=0;i!=size;i++)
             {
                    cout<             }
      }
      int main(void)
      {
            int i[10]={1,2,3,4,5,6,7,8,9,0};
            printValues(i);   //i作�ؓprintValues的实参，在这里�ؓ数组i的首地址�Q�或者说他�{换�ؓ成一个指�?br>            printValues2(i,10);
      }

      数组形参可以定义为引用或非引用类型。大部分情况下，数组以普通的非引用类型传�?此时数组会�?zh��n)��?zh��n)�的转换为指针。一般来��_��非引用类型的形参会初始化为其相应实参的副本。但是在传递数�l�时�Q�实参是指向数组�W�一个元素的指针�Q��Ş参复制的是这个指针的��|��而不是数�l�元素本�w�。函数操作的也是指针的副本，因此不会修改实参指针的倹{��然而，函数可通过该指针修改它所指向的数�l�元素的倹{�?br>
以上代码可以使用指针表示�Q�效果等同：

      void printValues3(const int *ia,int size)
      {
             for(size_t i=0;i!=size;i++,ia++)
             {
                 cout<<*ia<             }
       }

�C�Z��2�Q�通过引用传递数�l�）�Q?br>
      void printValues4(int (&arr)[10])    //�q�种情况下，数组大小成�ؓ形参和实参的一部分。编译器会检查数�l�大��是否匹配�?nbsp;int (&arr)[10] 中的��括��h��必须的�?br>      {
          for(size_t i=0;i!=10;i++)
          {
                 cout<          }
      }
      int main(void)
      {
            printValues4(i);
      }

      和其他类型一��P��数组形参可声明�ؓ数组的引用。如果�Ş参是数组的引用，�~�译器不会将数组实参转化为指针，而是传递数�l�的引用本��n�?

刘加�?/a> 2008-07-15 00:05 发表评论

传递指向指针的引用

Mon, 14 Jul 2008 14:19:00 GMT
代码�C�Z��Q?br>

//liujiajia
//2008-7-14
#include<iostream>
using namespace std;
void ptrswap(int *&,int *&);
int main(void)
{
    int i=10;
    int j=20;
    int *pi=&i;
    int *pj=&j;

    cout<<"调用ptr()之前:pi="<<pi<<",*pi="<<*pi<<";pj="<<pj<<",*pj="<<*pj<<endl;
    ptrswap(pi,pj);
    cout<<"调用ptr()之后:pi="<<pi<<",*pi="<<*pi<<";pj="<<pj<<",*pj="<<*pj<<endl;

    getchar();
    return 0;
}
void ptrswap(int *&v1,int *&v2)
{
    int *temp=v1;
    v1=v2;
    v2=temp;
}

在调用ptrswap之前�Q�pi指向i,pj指向j。在调用ptrswap之后�Q�pi指向j,而pj指向了i�?

刘加�?/a> 2008-07-14 22:19 发表评论

使用引用形参的优点和注意事项

Mon, 14 Jul 2008 13:48:00 GMT

使用引用形参的优点：

      在向函数传递大对象�Ӟ��需要��用引用�Ş参。虽然赋值实参对于内�|�数据类型的对象或者规模较?y��u)��的�cȝ��型来说没有什么问题，但是对于大部分的�cȝ��型或者大型数�l�，它的效率��比较低了。另外，某些�cȝ��型是无法复制的。��用引用�Ş参，函数可以直接讉K��实参对象�Q�而无��d��制它�?br>
�C�Z��Q?br>      bool isShorter(const string &str1,const string &str2)
      {
             return str1.size()      }
      �׃��string对象可能非常的长�Q�我们希望避免复制操作�?br>      如果使用引用形参的唯一目的是避免复制�Ş参，则应��Ş参定义�ؓconst引用�?br>
使用引用形参应该注意的：

      int incr(int &val)
      {
          return ++val;
      }
      void main(void)
      {
             short v1=1;
             const int v2=10;
             int v3=20;

             incr(v1);      //错误�Q�v1不是int
             incr(v2);      //错误�Q�v2是const
             incr(v3);      //正确
             incr(10);      //错误
      }

   所以，调用非const�c�d��的引用�Ş参，实参必须不是const�c�d��的，而且实参的类型和形参的类型应当一致�?/p>

刘加�?/a> 2008-07-14 21:48 发表评论

Mon, 14 Jul 2008 04:12:00 GMT
      一个函数只能有一个返回��|��但如果我惌��他返回更多的信息怎么办呢�Q�这�U�情况可以��用引用�Ş参�?br>      因�ؓ引用形参在函数调用后是可以修改实参值的�Q�所以就相当与函数的�q�回倹{�?br>
      下面的代码演�C�Z��一个带有一个返回��|��q��过引用形参向主调函数返回信息的函数。这个函数的功能是找出在容器中某一个数值出现的�ơ数�Q��ƈ�q�回该数值第一�ơ出现的�q�代器�?br>

//liujiajia
//2008-7-14
#include<iostream>
#include<vector>
using namespace std;
vector<int>::const_iterator find_val(vector<int>::const_iterator,vector<int>::const_iterator,int,vector<int>::size_type &);
int main(void)
{
    vector<int> some;
    int val;
    //使用push_back()输入容器中的�?nbsp;
    while(cin>>val)
    {
        some.push_back(val);
    }
    //存储值出现的�ơ数
    vector<int>::size_type ccurs;
    //调用函数
    vector<int>::const_iterator it=find_val(some.begin(),some.end(),8,ccurs);

    cout<<ccurs<<endl;

    getchar();
}

vector<int>::const_iterator find_val(
    vector<int>::const_iterator beg,
    vector<int>::const_iterator end,
    int value,
    vector<int>::size_type &occurs)
{
    vector<int>::const_iterator res_iter=end;
    occurs=0;
    for(;beg!=end;++beg)
    {
        if(*beg==value)
        {
            //�q�个if语句的作用是让res_iter�{�于值第一�ơ出现的位置
            if(res_iter==end)
            {
                res_iter=beg;
            }
            occurs++;
        }
    }
    return res_iter;
}



刘加�?/a> 2008-07-14 12:12 发表评论

函数的�Ş参（非引用�Ş参、指针�Ş参、引用�Ş参）

Sun, 13 Jul 2008 16:30:00 GMT
一、非引用形参

      void add1(int v1)
      {
          v1+=1;
      }

      �q�是最普通的形参方式�Q�当函数被调用时�Q�实参的副本初始化�Ş参，函数�q�没有访问调用所传递的实参�Q�因此v1+=1不会修改实参的倹{��对v1的操作只是修改了实参的一个副本�?br>
二、指针�Ş�?br>
      void add2(int *p)
      {
          *p+=1;
          p+=1;
      }

      使用指针做�ؓ函数的�Ş参，同样指针的��|��指针的地址�Q�不会因为p+=1而受到媄响，但是指针指向的地址的��|��*p�Q�将会改变。所以要想修改实参的��|��可以使用�q�种�Ҏ(gu��)��。但是还有一�U�更安全更自然的�Ҏ(gu��)��-引用形参

三、引用�Ş�?br>
      void swap(int &a,int &b)
      {
          int temp=a;
          a=b;
          b=temp;
       }

      引用形参直接兌��到其所�l�定的对象，而非�q�些对象的副本�?所以这�U�方法可以修改实参的��|��而且更加直观�?br>
三种�Ҏ(gu��)��实例代码�Q?br>
//liujiajia
//2008-7-14
#include<iostream>
using namespace std;
void add1(int);
void add2(int*);
void swap(int &,int &);
int main(void)
{
    int n=10;
    cout<<"调用add1()之前n="<<n<<endl;
    add1(n);
    cout<<"调用add1()之后n="<<n<<endl;

    int *p=&n;

    cout<<"调用add2()之前n="<<n<<",p="<<p<<endl;
    add2(p);
    cout<<"调用add2()之后n="<<n<<",p="<<p<<endl;

    int a=1,b=2;
    cout<<"调用swap()之前a="<<a<<",b="<<b<<endl;
    swap(a,b);
    cout<<"调用swap()之后a="<<a<<",b="<<b<<endl;

    getchar();
}

//非引用�Ş�?nbsp;
void add1(int v1)
{
    v1+=1;
}

//指针形参
void add2(int *p)
{
    *p+=1;
    p+=1;
}

//引用形参
void swap(int &a,int &b)
{
    int temp=a;
    a=b;
    b=temp;
}

刘加�?/a> 2008-07-14 00:30 发表评论

Fri, 20 Jun 2008 16:13:00 GMT
1.指向const对象的指�?/strong>

const int *p;
�q�个p是一个指向int�c�d��const对象的指针，const限定了指针p所指向的类型，而�ƈ非p本��n。也��是说p本��n�q�不是const。在定义时不需要对它进行初始化�Q�还可以�l�p重新赋��|��使其指向另一个const对象。但不能通过p修改所指向对象的倹{�?br>�C�Z��1�Q�int a=0; p=&a; 可以�?br>�C�Z��2�Q?p=20; 不可以�?br>�l�论�Q�这�U�指向const对象的指针只是限制不能修改p指向对象的数��|��而不是限制p指向什么对象�?br>
把一个const对象的地址赋给一个不是指向const对象的指针也是不行的�?br>�C�Z��3�Q�const int b=10;
               int *p2=&b;   //error
               const int *p3=&b; //ok
�l�论�Q�因为变量b有const修饰�Q�不能被修改。但指针p2是一个普通的指针�Q�可以修�Ҏ(gu��)��向对象的��|��两种声明矛盾�Q�所以不合法。而指向const对象的指针不允许修改指针指向对象的数��|��所以这�U�方式合法�?br>
2.const指针

int c=20;
int *const p4=&c;

指针p4�U�Cؓconst指针。它和指向const对象的指针恰好相反，它不能够修改所指向对象�Q�但却能够修�Ҏ(gu��)��向对象的数倹{��另外，�q�种指针在声明时必须初始化�?br>
3.指向const对象的const指针

const int d=30;
const int *const dp=&d;

指针dp既不能修�Ҏ(gu��)��向的对象�Q�也不能修改只想对象的倹{�?

刘加�?/a> 2008-06-21 00:13 发表评论

标准�?bitset �c�d��

Fri, 06 Jun 2008 15:04:00 GMT
有些�E�序要处理二�q�制有序集，每个位可能包�?值或�?倹{��位是保存一�l�项或条件yes/no信息的简�z�方法。标准库提供的bitset�cȝ��化了位集的处理。��用bitset �c�d��Q�必��d��含头文�g�Q?include

bitset对象的定义和初始�?br>
bitset b;               b有n位，每位都是0�Q?br>bitset b(u);           b是unsigned long型u的副本；
bitset b(s);            b是string对象s中含有的位串的副本；
bitset b(s,pos,n);   b是s中从位置pos开始的n个位的副本；

�C�Z��Q?br>    bitset<16> bitvec1(0xffff);         //bitvec1�?-15位都�?
    bitset<32> bitvec2(0xffff);         //bitvec2�?-15为是1�Q?6-31�?
    bitset<128> bitvec3(0xffff);      //bitvec3�?-15位是1�Q?6-127都是0

    string str("1100");
    bitset<32> bitvec4(str);            //bitvec4的第2、第3位是1�Q�其余都�?。因为string对象和bitset对象之间是反向�{化的�Q�string对象的最双��字符�Q�即下标最大的那个字符�Q�用来初始化bitset对象的低价位�Q�即��标�?的位�Q?br>
bitset对象的操作：

b.any()         b中是否存在置�?的二�q�制位？
b.none()       b中不存在�|��ؓ1的二�q�制位吗�Q?br>b.count()      b中��gؓ1的二�q�制位的个数
b.size()         b中二�q�制位的个数
b[pos]          讉K��b中在pos处的二进制位
b.test(pos)    b中在pos处的二进制位是否�?�Q?br>b.set()           把b中所有的二进制位都置�?
b.set(pos)      把b中在pos处的二进制位�|��ؓ1
b.reset()        把b中所有的二进制位都置�?
b.reset(pos)    把b中在pos处的二进制位�|��ؓ0
b.flip()            把b中所有二�q�制位逐位取反
b.flip(pos)      把b中在pos处的二进制位取反
b.to_ulong()   用b中同��L��二进制位�q�回一个unsigned long�?br>os<

刘加�?/a> 2008-06-06 23:04 发表评论

�q�代�?iterator

Fri, 06 Jun 2008 14:32:00 GMT
�q�代�?/strong>(iterator)是一中检查容器内元素�q��历元素的数据�c�d��?br>
每种容器�c�d��都定义了自己的�P代器�c�d��Q�如vector:
vector::iterator iter;�q�条语句定义了一个名为iter的变量，它的数据�c�d��是由vector定义的iterator�c�d��?br>
使用�q�代器读取vector中的每一个元素：
   vector ivec(10,1);

    for(vector::iterator iter=ivec.begin();iter!=ivec.end();++iter)
    {
        *iter=2;      //使用 * 讉K��q�代器所指向的元�?br>    }

const_iterator:
只能��d��容器中的元素�Q�而不能修攏V�?br>     for(vector::const_iterator citer=ivec.begin();citer!=ivec.end();citer++)
    {
        cout<<*citer;
        //*citer=3;   error
    }

vector::const_iterator �?const vector::iterator的区�?br>    const vector::iterator newiter=ivec.begin();
    *newiter=11;   //可以修改指向容器的元�?br>    //newiter++;     //�q�代器本�w�不能被修改

iterator的算术操作：
iterator除了�q�行++,--操作�Q�可以将iter+n,iter-n赋给一个新的iteraor对象。还可以使用一个iterator减去另外一个iterator.
    const vector::iterator newiter=ivec.begin();
    vector::iterator newiter2=ivec.end();
    cout<<"\n"<<newiter2-newiter;

刘加�?/a> 2008-06-06 22:32 发表评论

认识标准库vector�c�d��

Mon, 02 Jun 2008 15:48:00 GMT
vector是同一�U�类型的对象的集合，每个对象都有一个对应的整数索引倹{��和string对象一��P��标准库将负责��理与存储元素相关的内存。我们把vector�U�C��为容器。��用vector�c�d��必须包含 include�?br>vector 是一个类模板(class template)�?br>
vector的定义和初始化：
    vector text;            //保存�c�d��为string的对象，默认构造函数text为空
    vector text2(10);   //保存�c�d��为string的对象，包含10个空字符�?br>    vector ive(10,9);         //保存int的对象，保存10个��gؓ9的整形变�?br>    vector ive2(ive);         //使用ive初始化ive2

向vector��d��元素�Q?br>   while(cin>>word)
    {
        text.push_back(word);  //使用push_back可以向vector的后面插入新的元素�?br>    }
注意�Q?vector对象�Q�以及其他标准库容器对象�Q�的重要属性就在于可以在运行时高效的添加元素，因�ؓvector增长效率高，在元素值已知的情况下，最好是动态的��d��元素�?br>         *虽然可以对给定元素个数的vector对象预先分配内存�Q�但更有效的�Ҏ(gu��)��是初始化一个空vector对象�Q�然后再动态的增加元素�?br>
vector的下标操作：
for(vector::size_type ix=0;ix!=text.size();++ix)
    {
        cout<[ix]<    }
*使用vector::size_type�c�d��可以接收vector�c�d��的大��?br>*不在for循环之前取得vector的大��，而在for循环中计��text.size()�Q�是因�ؓvector是可以增长的�Q�所以它的元素数目是不确定的�?br>*和string对象一��P��vector可以通过下标直接讉K��元素�?br>
附表�Q�vector操作

v.empty() 如果v为空�Q�则�q�回true

v.size() �q�回v中元素的个数

v.push_back(t) 需按不�q�v的末��֢�加一个��gؓt的元�?/td>

v[n] �q�回v中位�|��ؓn的元�?/td>

v1=v2 吧v1的��g��替换为v2中元素的副本

v1==v2 如果v1与v2相等�Q�则�q�回true

!=,<,<=,>,>= 保持�q�些操作�W�惯有的含义

刘加�?/a> 2008-06-02 23:48 发表评论

c++字符处理 cctype

Sun, 01 Jun 2008 15:45:00 GMT
cctype头文件中定义的函敎ͼ�

isalnum(c) 如果c是字母或数字�Q�则为true

isalpah(c) 如果c是字母，则�ؓtrue

iscntrl(c) 如果c是控制字�W�，则�ؓtrue

isdigit(c) 如果c是数字，则�ؓtrue

isgraph(c) 如果c不是�I�格�Q�则为true

islower(c) 如果c是小写字母，则�ؓtrue

isprint(c) 如果c是可打印的字�W�，则�ؓtrue

ispunct(c) 如果c是标点符��P��则�ؓtrue

isspace(c) 如果c是空白字�W�，则�ؓtrue

isupper(c) 如果c是大些字母，则�ؓtrue

isxdigit(c) 如果c是十六进制数�Q�则为true

tolower(c) 如果c是大写字母，则返回小写字母�Ş式，否则�q�回c�?/td>

toupper(c) 如果c是小写字母，则返回大些字母�Ş式，否则�q�回c�?/td>

刘加�?/a> 2008-06-01 23:45 发表评论

string对象的操�?size() empty() 关系�q�算赋�?下标讉K��

Sun, 01 Jun 2008 15:22:00 GMT
string对象的操作：

size():用来获取字符串的长度�?br>输出字符串s的长度：
    string s("hello world!\n");
    cout<<"the size of '"<size()<
判断字符串是否�ؓ�I�的两种方式�Q?br>    if(s.size()==0)
    {
        cout<<"s.size==0"<    }
    if(s.empty())
    {
        cout<<"s.empty()"<    }

获得字符串长度：
    int num=s.size();    使用整�Ş接收字符串长度可能会有问题，因�ؓint变量的表�C��围太��，有时不能存储string对象的长度。��用string::size_type�c�d��可以满��要求�Q�这�U�类型是unsigned的，�q�比signed�c�d��要大一倍。事实上size()函数�q�回的也�?size_type �c�d��?br>
关系�q�算�Q?br>可以使用�Q�s1==s2�Q�s1>s2�Q�s1
赋��D��：
    string snew="empty";
    snew=s1;
上面代码首先初始化一个snew字符�Ԍ��W�二句将snew占用的内存释放掉�Q�然后给snew��_��存放s1副本的内存空��_��最后把s1中所有的字符复制到新分配的内存空间�?br>
字符串连接：
    cout<    cout<<"1"+s1<    cout<    cout<    //cout<<"hello"+"jiajia"<当进行string对象和字�W�串字面值�؜合连接操作时�Q?操作�W�的左右操作数必��至��有一个是string�c�d��的�?br>
通过下标讉K��string对象�Q?/strong>
    string对象下标�?开始�?br>    for(string::size_type ix=0;ix    {
        s1[ix]+=ix;
    }

刘加�?/a> 2008-06-01 23:22 发表评论

字符串的��d�� cin �?getline()

Sat, 31 May 2008 16:02:00 GMT
cin
    string s;
    cout<<"Enter some words...";
    cin>>s;
    cout<<"You write:"<*��d��q�忽略开头所有的�I�白字符�Q�空根{��换行符、制表符�Q��?br>*��d��字符直至遇到�I�白字符�Q�读取终止�?br>
getline()
    string line;
    cout<<"Enter a line...";
    getline(cin,line);
    cout<<"You write:"<*�q�个函数接收两个参数�Q�第一个是输入��对象，�W�二个是string对象�?br>*getline不忽略行开头的换行�W�，只要getline()遇到换行�W�，哪怕是�W�一个字�W�，getline也将停止��d��字符�q�返回�?br>*能够��d��除换行之外的�I�白字符�?br>

刘加�?/a> 2008-06-01 00:02 发表评论

Sat, 31 May 2008 15:48:00 GMT
C++初始化字�W�串的方式很灉|��Q?br>
#include<iostream>
#include<string>
using namespace std;
int main(void)
{
    string s1;              //初始化�ؓ�I�字�W�串
    string s2("hello");     //初始化�ؓ一个字�W�串字面副本
    string s3(s2);          //��s3初始化�ؓ一个s2的副�?nbsp;
    string s4="hi jiajia";  //初始化�ؓ一个字�W�串字面副本
    string s5(15,'A');
    cout<<s1<<endl<<s2<<endl<<s3<<endl<<s4<<endl<<s5<<endl;
    system("pause");
    return 0;
}

注意�Q�由于历史原因以及�ؓ了与C语言兼容�Q�字�W�串字面��g��标准库string�c�d��不是同一�U�类型�?

刘加�?/a> 2008-05-31 23:48 发表评论

命名�I�间的using声明

Sat, 31 May 2008 15:36:00 GMT
std::cout< : : 操作�W�是作用域解析符。它的含义是��x��作数的名字可以在左操作数的作用域中找到。std::cout 的意思是说所需名字cin是在命名�I�间std中定义的。这�U�符号引用标准库名字的方式是非常�ȝ��的�?br>     c++提供了一�U�简单的方式来��用命名空间成员，using声明。这是一�U�最安全的机制�?br>
#include<string>
#include<iostream>
using std::cin;
using std::endl;
using std::string;
int main(void)
{
    string s;  //正确。string使用了using声明
    cin>>s;    //正确。cin使用了using声明
    cout<<s;   //错误。cout没有使用using声明
    std::cout<<s<<endl; //正确。指定了命名�I�间
    system("pause");
    return 0;
}

命名�I�间扩展�Q?/strong>
        在标准C++以前�Q�都是用#include�q�样的写法的�Q�因��包含�q�来的头文�g名就是iostream.h。标准C++引入了名字空间的概念�Q��ƈ把iostream�{�标准库中的东东��装��C��std名字�I�间中，同时��Z��不与原来的头文�g��h��Q�规定标准C++使用一套新的头文�g�Q�这套头文�g的文件名后不�?h扩展名，如iostream、string�{�等�Q��ƈ且把原来C标准库的头文件也重新命名�Q�如原来的string.h��改成cstring(��是�?h��L��Q�前面加上字母c)�Q�所以头文�g包含的写法也��变成了#include �?
�q�不是写�?include��必��ȝ��using namespace std;我们通常�q�样的写的原因是��Z��一下子把std名字�I�间的东东全部暴露到全局域中�Q�就像是直接包含了iostream.h�q�种没有名字�I�间的头文�g一��P��Q��标准C++库用��h��与传�l�的iostream.h一��h��ѝ��如果不用using namespace std;使用标准库时��得时时带上名字�I�间的全名，如std::cout << "hello" << std::endl;
     #include "iostream"�?include的区别：前者先在当前目录找iostream文�g�Q�找不到再去�pȝ��头文件�\径找�Q�后者反之。因此，做�ؓ一个良好的习惯�Q�在包含�pȝ��头文件时��量�?lt;>�Q�而在包含自己的工�E�中的头文�g时用""�?

刘加�?/a> 2008-05-31 23:36 发表评论

v.empty()	如果v为空�Q�则�q�回true
v.size()	�q�回v中元素的个数
v.push_back(t)	需按不�q�v的末��֢�加一个��gؓt的元�?/td>
v[n]	�q�回v中位�\|��ؓn的元�?/td>
v1=v2	吧v1的��g��替换为v2中元素的副本
v1==v2	如果v1与v2相等�Q�则�q�回true
!=,<,<=,>,>=	保持�q�些操作�W�惯有的含义

isalnum(c)	如果c是字母或数字�Q�则为true
isalpah(c)	如果c是字母，则�ؓtrue
iscntrl(c)	如果c是控制字�W�，则�ؓtrue
isdigit(c)	如果c是数字，则�ؓtrue
isgraph(c)	如果c不是�I�格�Q�则为true
islower(c)	如果c是小写字母，则�ؓtrue
isprint(c)	如果c是可打印的字�W�，则�ؓtrue
ispunct(c)	如果c是标点符��P��则�ؓtrue
isspace(c)	如果c是空白字�W�，则�ؓtrue
isupper(c)	如果c是大些字母，则�ؓtrue
isxdigit(c)	如果c是十六进制数�Q�则为true
tolower(c)	如果c是大写字母，则返回小写字母�Ş式，否则�q�回c�?/td>
toupper(c)	如果c是小写字母，则返回大些字母�Ş式，否则�q�回c�?/td>

在线播放亚洲,亚洲免费在线观看,欧美va亚洲va日韩∨a综合色

最���单的windows�E�序

函数�q�回值的�Ҏ(gu��)��情况�Q�返回引用、非引用、引用左��|��

传递指向指针的引用

使用引用形参的优点和注意事项

函数的�Ş参（非引用�Ş参、指针�Ş参、引用�Ş参）

标准�?bitset �c�d��

�q�代�?iterator

认识标准库vector�c�d��

c++字符处理 cctype

string对象的操�?size() empty() 关系�q�算 赋�?下标讉K��

字符串的��d�� cin �?getline()

命名�I�间的using声明

最��单的windows�E�序

string对象的操�?size() empty() 关系�q�算赋�?下标讉K��