久久亚洲sm情趣捆绑调教,亚洲国产精品18久久久久久,久久精品中文字幕无码绿巨人

最��单的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�回值的�Ҏ��情况�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);
      }

      数组形参可以定义为引用或非引用类型。大部分情况下，数组以普通的非引用类型传�?此时数组会悄悄的转换为指针。一般来��_��非引用类型的形参会初始化为其相应实参的副本。但是在传递数�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

使用引用形参的优点：

      在向函数传递大对象�Ӟ��需要��用引用�Ş参。虽然赋值实参对于内�|�数据类型的对象或者规模较��的�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�种�Ҏ��。但是还有一�U�更安全更自然的�Ҏ��-引用形参

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

      引用形参直接兌��到其所�l�定的对象，而非�q�些对象的副本�?所以这�U�方法可以修改实参的��|��而且更加直观�?br>
三种�Ҏ��实例代码�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 发表评论

Sat, 12 Jul 2008 15:26:00 GMT
      动态数�l�，��֐�思义�Q�就是可以动态分配长度的数组。在c语言中，数组的长度是固定的，而这�U�限制显然是很不灉|��的。在c++中，数组有时候不用在�~�译时就知道长度�Q�直到运行时才知道。与普通的数组变量不同�Q�动态分配的数组��一直存在，直到�E�序昑ּ�的释攑֮�为止�?br>
定义�Q?/strong>

      int *p=new int[20];

      p��是一个动态数�l�，�q�时我们发现�Q�其实所谓的动态数�l�就是一个指针，使用new为p分配长度。我们可以通过�q�种方式初始化： int *p=new int[20]();

      同样上面的语句等同于�Q?br>      int n=20;
      int *p=new int[n];
      因�ؓn是一个变量，所以数�l�的长度是动态的�?br>
操作实例�Q?/strong>

      int n=20;
      int *p=new int[n];

      p可以使用数组下标为其赋��|��
      for(int i=0;i      {
            p[i]=i+3;
      }
     上面�q�种方式没有问题�Q�但我想既然p是一个指针，那么使用指针操作一样也可以吧？

     for(int i=0;i    {
           *p=i;
     }

      �q�样��可以了�Q�将他们输出�Q�（�q�时指针p又指向了最后）

      p--;
      for(int *p2=p-10;p2!=p;p--)
      {
           cout<<*p<      }

动态空间释放：

      最后重要的是别忘了��动态创造的�I�间释放掉，语句是：delete [] p;   ‘[ ]’表明该指针是指向的自由存储区的数�l�，而非单个对象。如果遗漏了�I�方括号�Q�编译器��无法发现这个错误，��导致程序在�q�行时出错�?br>
完成了！以下是完整代码：

#include<iostream>
using namespace std;
int main(void)
{
    int n=20;
    int *p=new int[n];
    for(int i=0;i<n;i++,p++)
    {
        cout<<p<<endl;
        *p=i;
    }
    p--;
    for(int *p2=p-n;p2!=p;p--)
    {
        cout<<*p<<endl;
    }

    delete [] p;

    getchar();
}

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

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�可以修�Ҏ��向对象的��|��两种声明矛盾�Q�所以不合法。而指向const对象的指针不允许修改指针指向对象的数��|��所以这�U�方式合法�?br>
2.const指针

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

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

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

指针dp既不能修�Ҏ��向的对象�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�但更有效的�Ҏ��是初始化一个空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 发表评论

开始学习c++语言

Sat, 31 May 2008 15:07:00 GMT
今天c语言的学习将告一�D�落。开始学习c++语言�?br>本来学习c��是��Z��学c++而准备的�Q�但是感觉进度有�Ҏ��了，看了些基��的，准备学c++了�?br>
对c++语言的学习，我将用那本经典的《C++ Primer�?中文�?。另外编辑器使用Dev-c++4.9.9.2�?

另外�Q�由于对C语言的学习和以前C++的一点基��Q�所以选择了《C++ Primer》这本书。但是，如果没有�q�方面的基础�Q�徏议看《C++ Primer Plus》这本书�?

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

sprint() 格式化写入字�W�串

Fri, 30 May 2008 16:01:00 GMT

�E�序从读取用戯��入的firstname,lastname和prize,�q�将他们��d��的值按照一定格式存储到另一个字�W�串数组内�?/p>
#include<stdio.h>
#define MAX 20
int main(void)
{
    char first[MAX];
    char last[MAX];
    char formal[2*MAX+10];
    double prize;

    puts("Enter your first name");
    gets(first);
    puts("Enter your last name");
    gets(last);
    puts("Enter your prize money");
    scanf("%lf",&prize);
    sprintf(formal,"%s,%-19s:$%6.2f\n",last,first,prize);
    puts(formal);

    getchar();
    getchar();
    return 0;
}

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

Fri, 30 May 2008 15:57:00 GMT
下面代码演示了程序��@环从用户输入��d��字符�Ԍ��q�存入��时的字符串数�l�，然后��时字�W�串复制到qwords数组里面�?br>

#include<stdio.h>
#include<string.h>
#define SIZE 40
#define LIM 5
int main(void)
{
    char qwords[LIM][SIZE];
    char temp[SIZE];
    int i=0;

    while(i<LIM && gets(temp))
    {
        strcpy(qwords[i],temp);
        i++;
    }
    puts("The list");
    for(i=0;i<LIM;i++)
    {
        puts(qwords[i]);
    }

    getchar();
    return 0;
}

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

strcmp() 比较字符串的内容

Fri, 30 May 2008 15:48:00 GMT
下面�E�序使用strcmp()验证�{�案是否正确�Q?br>

    char try[10];

    puts("Who is 1+1?");
    gets(try);
    while(strcmp(try,"2")!=0)
    {
        puts("No,it's wrong.Try again.");
        gets(try);
    }
    puts("OK,That's right");

下面�E�序说明各种情况下，strcmp()的返回��|��

printf("strcmp(\"a\",\"a\")=%d\n",strcmp("a","a"));
    printf("strcmp(\"a\",\"b\")=%d\n",strcmp("a","b"));
    printf("strcmp(\"b\",\"a\")=%d\n",strcmp("b","a"));
    printf("strcmp(\"a\",\"c\")=%d\n",strcmp("a","c"));
    printf("strcmp(\"c\",\"a\")=%d\n",strcmp("c","a"));
    printf("strcmp(\"abc\",\"abd\")=%d\n",strcmp("abc","abd"));
    printf("strcmp(\"abc\",\"abcd\")=%d\n",strcmp("abc","abcd"));
    printf("strcmp(\"abc\",\"abbd\")=%d\n",strcmp("abc","abbd"));

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

strcat()函数

Tue, 27 May 2008 12:12:00 GMT
strcat()接受两个字符串参数。将�W�二个字�W�串的一份拷贝添加到�W�一个字�W�串的结��，从而�ɽW�一个字�W�串成�ؓ一个新的组合字�W�串�Q�第二个字符串不改变�?br>

#include<stdio.h>
#include<string.h>
int main(void)
{
    char string1[20];
    char string2[]="goodbye";

    gets(string1);
    strcat(string1,string2);
    puts(string2);
    puts(string1);

    getchar();
    return 0;
}
以上�E�序��string2字符串的拯��攑ֈ�了string1的结��?br>
值得注意的是�Q�string1在被使用strcat()函数之前�Q�应该是已经初始化或者已�l�存储了一个字�W�串。因为如果字�W�串没有被初始化�Q�string1[]里面元素的存储是一串随机倹{��strcat()需要找到string1的结��（�W�一个出现的'\0'�Q?然后��L��q�个'0',最后把string2[]的拷贝放到string1[]最后一个值的后面�?

刘加�?/a> 2008-05-27 20:12 发表评论

Tue, 27 May 2008 11:32:00 GMT
函数原型�Q�size_t strlen(const char*)
作用�Q�返回参��C��字符串的长度�?br>
以下代码是一个截取字�W�串的例子：

#include<stdio.h>
#include<string.h>
void fit(char *,int);
int main(void)
{
    char msg[]="Hello moto";

    puts(msg);
    fit(msg,5);
    puts(msg);
    puts(msg+6);
    getchar();
    return 0;
}
void fit(char *string,int size)
{
    if(strlen(string)>size)
    {
        *(string+size)='\0';
    }
}
截取前：

H e l l o space m o t o \0

截取�?br>

H e l l o \0       m o t o \0

fit()是截取字�W�串的方法。如果字�W�串的长度大于要截取的长度，那么��指向该字符串的指针向后�U�d��size位后�Q�将指针指向的内容置�?\0'�Q�即字符串结束。但string+size+1处仍然存在一个字�W�串�?

刘加�?/a> 2008-05-27 19:32 发表评论

Tue, 27 May 2008 10:03:00 GMT
字符串输入：
gets()
    char name[20];
    printf("Hi,What's your name?\n");
    gets(name);
    printf("Nice name %s",name);
它��用一个地址把字�W�串赋予name�?br>
    char name[20];
    char *p;
    printf("\nEn,What's your name?\n");
    p=gets(name);
    printf("%s?Oh,Nice name %s\n",name,p);
get()的代码��用return 关键字返回字�W�串的地址�Q�程序把�q�个地址分配�l�指针p�?br>
fgets()
fgets()是�ؓ文�gI/O而设计的�Q�处理键盘输入不是特别方�ѝ�?br>
    printf("\nHi,What's your name?\n");
    p=fgets(name,20,stdin);
    printf("%s?Oh,Nice name %s\n",name,p);
*fgets()的第二个参数说明最大读入的字符数。如果这个参数��gؓn�Q�那么fgets()��׃��d��最多n-1个字�W�或��d��一个换行符为止。两个条件满��Q意一个结束�?br>*fgets()��d��到换行符�Q�就会把它存到字�W�串里，而不是想gets()那样丢弃它�?br>*fgets()的第三个参数说明��d��个文件。从键盘上读数据�Ӟ��可以使用stdin(代表standard input)作�ؓ参数�?br>
scanf()
    char name1[11], name2[11];
    int count;
    printf("\nPlease write down 2 names...\n");
    count=scanf("%5s %6s",name1,name2);
    printf("\nname1:%s\nname2:%s",name1,name2);

scanf()允许指定输入字符串长度等格式。上面的�E�序如果输入"liujiajia liujiajia",�E�序��输�?name1:liuji   name2:liujia";

字符串输出：
puts()
    char str[15]="hello world";
    const char *str2="HELLO WORLD";

    puts(str);
    puts(str2);
    puts(&str[5]);
    puts(str2+2);
puts()昄��字符串时自动在其后添加一个换行符�?br>puts(&str[5]);��输��Z��str的第六个元素开始到字符串结束�?br>puts(str2+2);��输��Z��str2的地址向后�U�d��两个字符开始到字符串结束�?br>
fputs()
    fputs(str,stdout);
    fputs(str2,stdout);
    fputs(&str[5],stdout);
    fputs(str2+2,stdout);
*fputs()�W�二个参数表�C��写的文�g。可以��用stdout(代表standard output)作�ؓ参数�?br>*fputs()不自动输出换行符�Q�这与puts()不太相同�?br>
printf()
�q�个不用多说了�?

刘加�?/a> 2008-05-27 18:03 发表评论

Fri, 23 May 2008 16:27:00 GMT

字符串数�l�初始化�Q?/span>
(1)char arr[10]="HI";
初始化字�W�串数组�Ӟ��~�译器自动将字符串最后一个字�W�后面加�?\0',以表�C�字�W�串的结束�?br>如果数组的大��大于字�W�串的长�?1�Q�那么把字符串结束后面的元素也都初始化�ؓ'\0';
看这�D늨�序：
定义一个大��ؓ12的字�W�串数组
char str1[12]="jiajia";
让一个char型的指针指向�q�个数组
    char *p1=str1;
输出�q�个字符�?br>    printf("%s\n\n",str1);
利用指针输出�q�个字符串数�l�中每个元素的字�W�、字�W�ascii倹{��字�W�存储地址
    for(int i=0;i<12;i++)
    {
        printf("%c:%d:%p\n",*p1,*p1,p1);
        p1++;
    }
可以看出�Q�数�l�元素的后几位都被初始化成了'\0';使用printf打印字符串数�l�时�Q�程序遇到第一�?\0'��q��束对字符串的��d��?br>
如果数组的大��小于字�W�串的长�?1�Q�程序在�q�行时可能要出现问题�Q�所以应当确保数�l�的大小要大于字�W�串长度的大��?1�Q?br>
�q�段�E�序的字�W�串长度+1��于数组的大��：
char str2[12]="hello jiajia";
    char *p2=str2;

    printf("\n\n\n%s\n\n",str2);

    for(int i=0;i<28;i++)
    {
        printf("%c:%d:%p\n",*p2,*p2,p2);
        p2++;
    }

使用printf打印字符�Ԍ��E�序需要找�?\0'才能�l�束��d��Q�结果找遍整个数�l�没有找刎ͼ�只有�l�箋��着地址��L��Q�一直找到某个地址上的assii�?的，字符串才��d��完毕。所以本�D늨�序在��d��?hello jiajia"之后�Q�后面可能还会有几个随机的字�W�，��是因�ؓ字符串终止于'\0'�?br>
(2)char arr[]="Hello World!";
�q�种初始化方法不用担心数�l�大��过��的情况�Q�数�l�的大小��q��译器军_��?br>(3)char arr[]={'H','e','e','l','o',' ','W','o','r','l','d','\0'};
同第二种�Ҏ��l�果相同�Q�但昄��要麻烦许多。另外，' '代表�I�格�Q�ascii值是32�Q?\0'代表字符串结束，ascii值是0�Q?br>(4)char *p="Hello World";
使用数组的方式初始化。同数组不同之处在于,p是一个变量，可以做递增、递减�q�算�Q�而arr是数�l�的首地址�Q�是一个地址帔R��Q�不能做递增、递减�q�算�?br>
char *name="liujiajia";
    name[0]='L';
    printf("\n%s\n",name);
name[0]='L';�q�句代码在最新的c99标准中会引发�E�序异常。需要注意�?br>

char *string="c programe";
    char *string2;
    string2=string;    //��指针string的��D��l�string2

    printf("\nstring=%s,&string=%p,string=%p\n",string,&string,string);
    printf("\nstring=%s,&string=%p,string=%p\n",string2,&string2,string2);

上面�q�段�E�序最后显�C�，指针string所指向的地址和指针string2所指向的地址相同�Q�这��p��明它们指向的是内存里面同一个字�W�串�Q�也��是说字�W�串本��n�q�没有复�Ӟ��而是产生了一个指向同一个字�W�串的指针。这��L��序的效率会更加的高。如果需要复制字�W�串可以使用 strcpy() �?strncpy()�?br>

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

函数和二�l�数�l�的新认�?参数指定数组�W�二�l�和�W�一�l�大��?

Tue, 20 May 2008 14:31:00 GMT

#include<stdio.h>
#define ROWS 3
#define COLS 4
void sum_rows(int arr[][COLS],int rows);
int main(void)
{
    int junk[ROWS][COLS]={{1,2,3,4},{5,6,7,8},{9,10,11,12}};

    sum_rows(junk,ROWS);//求出每行的数值��d��?nbsp;

    getchar();
    return 0;
}
void sum_rows(int arr[][COLS],int rows)
{
    int r,c,tot;
    for(r=0;r<rows;r++)
    {
        tot=0;
        for(c=0;c<COLS;c++)
        {
            tot+=arr[r][c];
        }
        printf("row%d,sum=%d\n",r,tot);
    }
}

我们都知道上面的代码可以��利执行�Q?sum_rows()的�Ş参是 int arr[][COLS],没有指定数组的第一�l�大��。但是设想一下，如果不指定第二维的大��，�l�果会怎样呢？
我写了以下例子：

#include <stdio.h>
int sum2d(int arr[][],int row,int col);
int main(void)
{
    int arr[3][4]={{1,2,3,5},{3,4,4,5},{2,3,4,5}};
    sum2d(arr,3,4);

    getchar();
    return 0;
}
int sum2d(int arr[][],int row,int col)
{
    for(int i=0;i <row;i++)
    {
        for(int j=0;j <col;j++)
        {
            printf("%d",arr[i][j]);  invalid use of array with unspecified bounds
        }
    }
    return 0;
}
�q�行后发玎ͼ��E�序报错了，�q�是��Z��么呢�Q�百思不得其解，后来��h��了CSDN上老大们。终于稍微弄明白了点�ѝ��我惛_��体应该从两方面证明�ؓ什么上面的�E�序不可行�?br>�Q?�Q�从二维数组的存储方式上�Q�二�l�数�l�在内存上是一行一行连�l�的存储的。如下图�Q?br>arr[3][4]

arr[0][0] arr[0][1] arr[0][2] arr[0][3] arr[1][0] arr[1][1] arr[1][2] arr[1][3] ...

因�ؓarr是这个数�l�的首地址�Q�我们可以知道arr[0][0]的地址。只要我们知道arr[][4]中数�l�第二维的大��?#8216;4’�Q�我们就可以扑ֈ��L��行和列的地址。address=arr+(rows-1)*4+cols。但是如果不知道�W�二�l�的大小�Q�那么条件就不够了。打一个比方，��若�q�个学生分成每组11人，�q�让他们站成一排，�q�时我们可以定位出第几组的第几个学生。但如果不知道每�l?1个�h�Q�那么我们显然就无法定位了�?br>
�Q?�Q�从指针的角度上�?�q�种思�\我还是有点迷�p?:大家可以参看�q�个帖子�Q?a >http://topic.csdn.net/u/20080520/09/2122e210-5cf5-4b75-b31f-c2523b00cf53.html?575319732

恩，现在是越学越�q�h��了。呵��c�?br>

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

Mon, 19 May 2008 15:03:00 GMT
阅读下面代码�Q�程序列举了3�U�二�l�数�l�作为参��C��递的�Ҏ��Q?br>
#include<stdio.h>
#define ROWS 3
#define COLS 4
void sum_rows(int arr[][COLS],int rows);
void sum_cols(int [][COLS],int);        //可以省略名称
int sum2d(int (*arr)[COLS],int rows);   //另一�U�语法�Ş�?/span>
int main(void)
{
    int junk[ROWS][COLS]={{1,2,3,4},{5,6,7,8},{9,10,11,12}};

    sum_rows(junk,ROWS);//求出每行的数值��d��?nbsp;
    printf("\n");       //求出每列的数值��d��?nbsp;
    sum_cols(junk,ROWS);//求出全部数值的��d��?nbsp;

    printf("\nthe sum of the junk is %d",sum2d(junk,ROWS));

    getchar();
    return 0;
}
void sum_rows(int arr[][COLS],int rows)
{
    int r,c,tot;
    for(r=0;r<rows;r++)
    {
        tot=0;
        for(c=0;c<COLS;c++)
        {
            tot+=arr[r][c];
        }
        printf("row%d,sum=%d\n",r,tot);
    }
}
void sum_cols(int arr[][COLS],int rows)
{
    int r,c,tot;
    for(c=0;c<COLS;c++)
    {
        tot=0;
        for(r=0;r<rows;r++)
        {
            tot+=arr[r][c];
        }
        printf("col%d,sum=%d\n",c,tot);
    }
}

int sum2d(int (*arr)[COLS],int rows)
{
    int r,c,tot=0;
    for(r=0;r<rows;r++)
    {
        for(c=0;c<COLS;c++)
        {
            tot+=arr[r][c];
        }
    }
    return tot;
}

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

Mon, 19 May 2008 14:28:00 GMT
一、多�l�数�l�地址和指针的关系
int arr2[4][2]={{1,2},{3,4},{5,6},{7,8}};
printf("arr2=%p,&arr2[0]=%p,arr2[0]=%p,&ar2r[0][0]=%p\n",arr2,&arr2[0],arr2[0],&arr2[0][0]);

arr[0][0] (1) arr[1][0] (3) arr[2][0] (5) arr[3][0] (7)

arr[0][1] (2) arr[1][1] (4) arr[2][1] (6) arr[3][1] (8)

上面的程序的�l�果输出竟然都一栗��ؓ什么呢�Q?br>首先 arr2 代表的是arr2数组的首地址�Q�所�?arr2的值和 arr2�W�一个子元素arr2[0]的地址相同�Q�即 &arr2[0]�Q?br>arr2[0]是含有两个整形元素一�l�数�l�的首地址�Q�即&arr2[0][0]的倹{�?br>��单的��_��arr[0]是一个整数大��对象的地址�Q�arr2是两个整数大��对象的地址。因为整数和两个整数�l�成的数�l�开始于同一个地址�Q�所�?arr2 �?arr2[0] ��h��相同的数倹{�?br>
二、指针（地址�Q�运��和多维数组的关�p?/strong>
printf("arr2+1=%p,arr2[0]+1=%p\n",arr2+1,arr2[0]+1);
现在我们知道�Q�arr2 �?arr2[0]��h��相同的数��|��但是arr2+1和arr2[0]+1��Z��么数��g��一样呢�Q�这是因为，arr2指向的对象大��是两个int�Q�儿arr2[0]所指向的大��是一个int。所以arr2+1的��D��比arr2[0]+1的值多一个int大小�?br>
三、��?对多�l�数�l�取�?/strong>
因�ؓ arr2[0] �?arr2[0][0]的首地址�Q�所�?*(arr2[0])代表存储在arr2[0][0]的倹{��同��P��arr2是arr2[0]的首地址�Q?arr��是 arr2[0]的倹{��但�?arr2[0]也是一个地址�Q�即&arr2[0][0],因此*arr2�?&arr2[0][0]。所�?*&arr2[0][0] �{��h�?**arr2�?&arr2[0][0] 可以��化�ؓ arr2[0][0]。所�?arr2[0][0]==**arr2�?br>��而言之：arr2是地址的地址�Q�所以需要经�q�两�ơ取值才能取到具体的数倹{�?br>

学完�q�个知识点，才发现在指针��实很难懂�?br>

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

Mon, 19 May 2008 11:08:00 GMT

�Ҏ��针可以进�?strong>赋�?/strong>�?strong>求�?/strong>�?strong>取�?/strong>�?strong>取指针的地址�?strong>��一个指针加上一个整�?/strong>�?strong>增加指针的�?/strong>�?strong>求差�?/strong>的操作。请参看以下代码展示了几�U�情形：

#include<stdio.h>
int main(void)
{
    int urn[5]={100,200,300,400,500};
    int *p1,*p2,*p3;

    p1=urn;         //把一个地址赋给指针
    p2=&urn[2];     //取得urn[2]的地址�Q��ƈ赋给一个指�?/span>

    printf("数组各个元素的值和地址�Q�\n");
    for(int i=0;i<5;i++)
    {
        printf("urn[%d]=%d   &urn[%d]=%p;\n",i,urn[i],i,&urn[i]);
    }

    printf("\n指针指向的地址,指针指向地址的�?指针的地址\n");
    printf("p1=%p    ,*p1=%d         ,&p1=%p",p1,*p1,&p1);

    printf("\n指针加上整数的效�?指针+int!=指针�Q�指�?int==地址)�Q�\n");
    printf("p1+4=%p,*(p1+4)=%d",p1+4,*(p1+4));

    //printf("&(p1+4)=%p",&(p1+4))//error:p1+4是一个地址�Q�不能对其进行取地址操作�Q�但可以��p1+4赋给一个指�?nbsp;

    p1++;//p++==p1+1。p1+1是一个地址�Q�将p1+1赋给p1
    printf("\n在p1++以后�Q�\np1=%p    ,*p1=%d         ,&p1=%p\n",p1,*p1,&p1);

    //求两个指针差�?nbsp;
    printf("\np2=%p,p1=%p,p2-p1=%d\n",p2,p1,p2-p1);

    getchar();
    return 0;
}

刘加�?/a> 2008-05-19 19:08 发表评论

Fri, 16 May 2008 15:54:00 GMT

传递数�l�参敎ͼ�其核心就是传递该数组的首地址。然后函数再通过数组、指针等�Q�用该数�l�的首地址构造一个新的数�l�或指针�Q�再通过传递过来的数组大小�Q�对该数�l�进行操作�?/p>
#include <stdio.h>
#define SIZE 4
int sumbyarr(int a[],int n);
int sumbypointer(int *p,int n);
int sumbyaddress(int address,int n);
int sumbypointer2(int *begin,int *end)
int main(void)
{
    int arr[SIZE]={10,20,30,40};
    int sum1;
    //使用数组作�ؓ形参接收数组
    sum1=sumbyarr(arr,SIZE);
    printf("the total of the arr by array is:%d\n",sum1);
    //使用指针作�ؓ形参接收数组
    int sum2;
    sum2=sumbypointer(arr,SIZE);
    printf("the total of the arr by pointer is:%d\n",sum2);
    //使用地址作�ؓ形参接收数组
    int sum3;
    sum3=sumbyaddress(arr,SIZE);
    printf("the total of the arr by address is:%d\n",sum3);

    //使用两个指针形参接收
    int sum4;
    sum4=sumbypointer2(arr,arr+SIZE);
    printf("the total of the arr by pointer2 is:%d\n",sum4);

    getchar();
    return 0;
}
int sumbyarr(int a[],int n)
{
    int index;
    int total=0;
    for(index=0;index<n;index++)
    {
        total+=a[index];
    }
    return total;
}
int sumbypointer(int *p,int n)
{
    int index;
    int total=0;
    for(index=0;index<n;index++,p++)
    {
        total+=*p;
    }
    return total;
}
int sumbyaddress(int address,int n)
{
    int *p=address;
    int index;
    int total=0;
    for(index=0;index<n;index++,p++)
    {
        total+=*p;
    }
    return total;
}
int sumbypointer2(int *begin,int *end)
{
    int total=0;
    while(begin    {
        total+=*begin;
        begin++;
    }
    return total;
}

以上代码演示怎样定义有数�l�作为参数的函数�?br>如果数组作�ؓ参数传递进入某个函敎ͼ��q�且在这个函��C��改变了数�l�元素的��|��那么�E�序�q�回后，�q�个数组元素的值有没有改变呢？

当然�Q�值改变了�Q�因为数�l�是通过地址传递的�Q�改变了被调函数中数�l�的��g��意味着同时改变了主调函��C��数组的倹{��因为它们的地址是相同的�?

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

认识数组和指针的关系

Fri, 16 May 2008 13:30:00 GMT

   int arr[SIZE]={1,2,3,4};
    int index;
    for(index=0;index    {
        printf("arr[%d]=%d address=%p\n",index,arr[index],arr+index);
    }

    int *p=arr;
    for(index=0;index    {
        printf("*(p+%d)=%d     p+%d=%p\n",index,*(p+index),index,p+index);
    }

    getchar();
    return 0;

以上代码展示了读取数�l�中元素的两�U�方式，�W�一�U�是常规的��用数�l�下标来��d��。第二种�Ҏ��是��用指针来��d��数组�?br>
通过�W�一中方法中打印出来的内容，我们可以认识刎ͼ�数组名其实就是这个数�l�的首地址�Q�即�Q�arr=数组首地址;arr+1:数组�W�二个元素的地址�Q�arr+2�Q�数�l�第三个元素的地址�Q�以此类推。。�?br>
�W�二�U�方法我们��用指针访问代替了数组下标讉K��Q�我们将 arr(��x��l�的首地址)赋值给了指�?*p�Q�所�?p��q��于arr的首地址�Q�p+1��q��于arr的二个元素的地址�Q�那�?p��q��当于了arr[0],*(p+1)��q��当于arr[1]�?br>
我们从中可以得出一个结论：数组标记实际上是一�U�变�怋�用指针的形式�?

刘加�?/a> 2008-05-16 21:30 发表评论

Thu, 15 May 2008 16:06:00 GMT

#include<stdio.h>
#define PLAYER 4
#define MATCH 3
int main(void)
{
    //��?名球员近三场比赛的得分初始化
    int arrmark[MATCH][PLAYER]={
        {9,8,7,5},
        {8,10,8,7},
        {7,7,10,6}
        };
    //输出具体成�W
    int i,j;
    printf("***********Roony  Ronaldo  Kaka  Grosso\n");
    for(i=0;i<MATCH;i++)
    {
        printf("match%d:",i);
        for(j=0;j<PLAYER;j++)
        {
            printf("%8d",arrmark[i][j]);
        }
        printf("\n");
    }
    //打印��d��
    int temp=0;
    printf("total        ");
    for(i=0;i<PLAYER;i++)   //求每个球员的��d��
    {
        for(j=0;j<MATCH;j++)
        {
            temp+=arrmark[j][i];
        }
        printf("%d      ",temp);
        temp=0;
    }
    getchar();
}

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

指定数组大小

Thu, 15 May 2008 15:32:00 GMT
指定数组大小也有很多方式�Q?br>    char arr[10];                                    //OK
    char arr2[1+2*7];                            //OK
    char arr3[sizeof(char)+2];                //OK
    char arr4[-2];                                  //error 数组大小不能使用负数
    char arr5[0];                                   //�Ҏ��~�译器不同，有的�~�译器�{换�ؓ“arr5[]”,有的�~�译不通过�?/span>
    char arr6[3.14];                            //error
    char arr7[(int)3.14];                       //强制转换为int
    int m=2;
    char arr9[m];                                //c99前不允许

注意�Q�c99标准允许使用变量指定数组大小�?

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

Thu, 15 May 2008 15:11:00 GMT
以下代码展示数组初始化的各种情况�Q?br>
#include<stdio.h>
#define SIZE 4
int main(void)
{
    //一般初始化
    int arr[SIZE]={1,2,3,4};
    int index;
    for(index=0;index<SIZE;index++)
    {
        arr[index]++;
        printf("arr[%d]=%d\n",index,arr[index]);
    }

    //定义�q�初始化一个const数组。数�l�内元素不能修改
    int const arr2[SIZE]={1,2,3,4};

    //数组不初始化�Q�元素的��gؓ随机数�?nbsp;
    int arr3[SIZE];
    for(index=0;index<SIZE;index++)
    {
        printf("arr3[%d]=%d\n",index,arr3[index]);
    }

    //如果初始化数�l�中部分元素�Q�其他元素则被初始化�?
    int arr4[SIZE]={1,2};
    for(index=0;index<SIZE;index++)
    {
        printf("arr4[%d]=%d\n",index,arr4[index]);
    }
    //指定要初始化的元�?/span>
    int arr5[SIZE]={1,[2]=3,[3]=4};
    for(index=0;index<SIZE;index++)
    {
        printf("arr5[%d]=%d\n",index,arr5[index]);
    }

    //数组的元素个��C��固定
    int arr6[]={1,2,3,4,5,6,7,8};
    printf("sizeof arr6=%d,sizeof arr6[0]=%d\n",sizeof arr6,sizeof arr6[0]);
    for(index=0;index<sizeof arr6/sizeof arr6[0];index++)
    {
        printf("arr6[%d]=%d\n",index,arr6[index]);
    }
    return 0;
}

�E�序�q�行�l�果是：

怎么��P��数组的初始化方式多种多样。但要灵�z�运用�?

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

认识sizeof

Thu, 15 May 2008 08:01:00 GMT
sizeof 是C语言里面的一个运��符�Q��ƈ且以字节为单位返回其操作数的大小。操作数可以使一个具体的数据对象、变量类型、一个操作数。�ƈ且返回类型�ؓsize_t�Q�size_t是在stddef.h头文仉��定义的，原型是：typedef unsigned int size_t;
以下代码演示sizeof用法�Q?br>
#include<stdio.h>
#include<stddef.h>
#include<stdlib.h>
int main(void)
{
    int i;
    printf("sizeof(2008)=%d\n",sizeof(2008));
    printf("sizeof(i)=%d\n",sizeof(i));
    printf("sizeof i=%d\n",sizeof i);
    printf("sizeof(int)=%d\n",sizeof(int));
    //printf("sizeof int=%d\n",sizeof int); //sizeof int写法错误�Q?nbsp;
    printf("sizeof(char)=%d\n",sizeof(char));
    printf("sizeof(float)=%d\n",sizeof(float));
    printf("sizeof(double)=%d\n",sizeof(double));

    return 0;
}

�q�行�l�果昄��Q?br>

另外�Q�sizeof 可以应用于数�l�、结构等情况�Q�请参考这��文章：http://blog.chinaunix.net/u/20828/showart_438003.html

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

使用igoogle

Wed, 14 May 2008 16:00:00 GMT
大家有没有用�q�google的自定义主页�Q�就�?igoogle 。可以自己添加google��Z��提供的小工具来组成你的主��c��里面有个google眼睛�Q�感觉很好玩�?br>可是我同时想把我一些常用的链接放进去，但是igoogle�q�没有提供相关的工具�Q�怎么办？没关�p�，google��Z��提供了小工具开发的接口�?br>
1.�q�入 igoogle �?br>2.点击“��d��内容”链接�?br>3.点击“��d��供稿源或��工�?#8221;�Q�输�?#8216;http://helloliukai.googlepages.com/hi.xml’ 点击��d��?br>4.然后回到首页�Q�你可以看到你的igoogle主页上添加了一个名�?#8216;hello world example’的小工具�?br>
呵呵�Q�你只要打开http://helloliukai.googlepages.com/hi.xml �q�个xml文�g��׃��发现其中的问题了�?br>igoogle通过解析xml文�g来向用户展示��工兗��你只要�?#8220;”中的“Hello, world!”替换成�Q意html或javascript代码��p��了。然后把修改�q�的xml文�g上传��C��个公��q��I�间里面��p��了。我用的同样是google的��品，Page Creator�Q?a >http://pages.google.com/ 。呵��c��google的东东确实很多�?br>另外�Q�xml��实也很强大�?br>
http://code.google.com/intl/zh-CN/apis/gadgets/ �q�里有google的资源，有教�E�和��编辑器。但教程感觉已经�q�期了，好多里面的代码都不能用。可以��用那个小�~�辑器打开各种模板�?

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

认识递归函数

Tue, 13 May 2008 16:08:00 GMT

#include<stdio.h>
void testfunc(int);
int main(void)
{
    testfunc(1);
    return 0;
}
void testfunc(int n)
{
    printf("Lv%d:%p\n",n,&n); //%p 地址昄��格式
    if(n<4)
    {
        testfunc(n+1);  //testfunc()调用了自�?/span>
    }
    printf("2Lv%d:%p\n",n,&n);
}
以上是一个递归的示例�?br>testfunc()在内部调用了自己�Q�这��L��后果是：暂时不执行最后面�?#8220;printf("2Lv%d:%p\n",n,&n);”�Q�而是��?n+1作�ؓ参数调用了自己，�q�样重复�Q�最�l�程序的�l�果是：

(�Ҏ��电脑不同�Q�地址可能有所不同)
�E�序具体�q�行步骤�Q?br>1.main()调用testfunc(1)
2.testfunc(1)执行�Q�打�?#8220;lv1:0022FF60”�Q?022FF60是n的地址
3.n<4,条�g成立�Q?nbsp;testfunc(1)调用testfunc(2)
4.testfunc(2)执行�Q�打�?#8220;lv1:0022FF40”,因�ؓ此时testfunc(2)的变量n已经不是testfunc(1)中的变量n了，所以地址不同。（函数的参��C��用域只在当前函数�Q?br>5.n<4�Q�条件成立，testfunc(2)调用testfunc(3)
6.testfunc(3)执行�Q�打�?#8220;lv1:0022FF20”
7.n<4�Q�条件成立，testfunc(3)调用testfunc(4)
8.testfunc(4)执行�Q�打�?#8220;lv1:0022FF00”
9.n<4,条�g不成立，打印“2lv1:0022FF00”
10.�q�回调用testfunc(4)的testfunc(3),打印“2lv1:0022FF20”
11.�q�回调用testfunc(3)的testfunc(2),打印“2lv1:0022FF40”
12.�q�回调用testfunc(2)的testfunc(1),打印“2lv1:0022FF60”

OK,�q�就是函数的递归调用�Q�通俗的说��是函数自己调用自己。以前学时没有弄明白�Q�现在终于弄明白了�?br>

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

认识getchar()和putchar()

Fri, 09 May 2008 14:55:00 GMT
getchar()函数没有参数�Q�返回输入设备的下一个字�W��?br>ch=getchar(); �?scanf("%c",&ch);是同��L��效果�?br>

putchar()函数用来打印它的参数�?br>putchar(ch); �?printf("%c",ch); 是同��L��效果�?br>
�q�两个函数都�?stdio.h 文�g中定义了�?

刘加�?/a> 2008-05-09 22:55 发表评论

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>

arr[0][0] (1)	arr[1][0] (3)	arr[2][0] (5)	arr[3][0] (7)
arr[0][1] (2)	arr[1][1] (4)	arr[2][1] (6)	arr[3][1] (8)

久久亚洲sm情趣捆绑调教,亚洲国产精品18久久久久久,久久精品中文字幕无码绿巨人

最���单的windows�E�序

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

传递指向指针的引用

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

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

标准�?bitset �c�d��

�q�代�?iterator

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

c++字符处理 cctype

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

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

命名�I�间的using声明

开始学习c++语言

sprint() 格式化写入字�W�串

strcmp() 比较字符串的内容

strcat()函数

函数和二�l�数�l�的新认�?参数指定数组�W�二�l�和�W�一�l�大��?

认识数组和指针的关系

指定数组大小

认识sizeof

使用igoogle

认识递归函数

认识getchar()和putchar()

最��单的windows�E�序

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