C++博客-刘加加在成长(C++语言学习中)

最简单的windows程序

刘加加 — Wed, 23 Jul 2008 09:01:00 GMT

1.打开vc++;
2.选择菜单栏file----new；
3.选项卡选择Projects；
4.模板选择 Win32 Application;
5.输入Project name；
6.Loction 选择路径；
7.点击OK继续；
8.选择默认的“An Empty project”；
9.点击finish完成创建工程；
10.向工程里面添加一个c++文件；（file--new--选项卡file--C++ source file--输入文件名--点击OK）
11.输入以下代码；

#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.保存，按ctrl+F5编译并运行。
13.弹出一个对话框。

以上就是号称世界上最简单的Windows程序！

刘加加 2008-07-23 17:01 发表评论

函数返回值的特殊情况（返回引用、非引用、引用左值）

刘加加 — Tue, 15 Jul 2008 16:41:00 GMT

返回非引用

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

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

返回引用

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

      以上函数的返回值是引用类型。无论返回s1或是s2,调用函数和返回结果时，都没有复制这些string对象。

千万不要返回局部对象的引用

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

      当函数执行完毕，程序将释放分配给局部对象的存储空间。此时，对局部对象的引用就会指向不确定的内存。（我在dev c++里运行通过。。。。但是vc6和vc2008不能编译通过）。同理，也不能返回局部对象的指针。


引用返回左值（比较奇妙）

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

      使用语句调用:
       string s("123456");
       cout<       get_val(s,0)='a';
       cout<      把函数应用于左值，还是第一次见到（真是孤陋寡闻）。

以下是上面几种情况的实例代码：

//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;
}
//返回非引用
string make_plural(size_t i,const string &word,const string &ending)
{
    return (i==1)?word:word+ending;
}
//返回引用
const string &shorterString(const string &s1,const string &s2)
{
    return s1.size()<s2.size()?s1:s2;
}
//禁止返回局部对象的引用（我的dev c++ 没有报错，比较可怕）
const string &mainip(const string &s)
{
    string ret=s;
    return ret;
}
//引用返回左值（第一次听说）
char &get_val(string &str,string::size_type ix)
{
    return str[ix];
}

刘加加 2008-07-16 00:41 发表评论

数组的形参

刘加加 — Mon, 14 Jul 2008 16:05:00 GMT

      数组有两个特殊的性质，影响我们定义和使用作用在数组上的函数：一是不能复制数组。二是使用数组名字时，数组会自动转换为指向其第一个元素的指针。因为数组不能复制，所以无法编写使用数组类型形参的函数。因为数组会被初始化为指针，所以处理数组的函数通常通过操作指向数组中的元素的指针来处理数组。

示例：

      //形式1
      void printValues(const int ia[10])     //虽然形参指定了数组的大小，但编译时不会检查实参数组大小，因为编译器只检查形参是否是指针，并且指针类型和数组元素的类型是否匹配。
      {
             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的首地址，或者说他转换为成一个指针
            printValues2(i,10);
      }

      数组形参可以定义为引用或非引用类型。大部分情况下，数组以普通的非引用类型传递,此时数组会悄悄的转换为指针。一般来说，非引用类型的形参会初始化为其相应实参的副本。但是在传递数组时，实参是指向数组第一个元素的指针，形参复制的是这个指针的值，而不是数组元素本身。函数操作的也是指针的副本，因此不会修改实参指针的值。然而，函数可通过该指针修改它所指向的数组元素的值。

以上代码可以使用指针表示，效果等同：

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

示例2（通过引用传递数组）：

      void printValues4(int (&arr)[10])    //这种情况下，数组大小成为形参和实参的一部分。编译器会检查数组大小是否匹配。 int (&arr)[10] 中的小括号是必须的。
      {
          for(size_t i=0;i!=10;i++)
          {
                 cout<          }
      }
      int main(void)
      {
            printValues4(i);
      }

      和其他类型一样，数组形参可声明为数组的引用。如果形参是数组的引用，编译器不会将数组实参转化为指针，而是传递数组的引用本身。

刘加加 2008-07-15 00:05 发表评论

传递指向指针的引用

刘加加 — Mon, 14 Jul 2008 14:19:00 GMT

代码示例：

//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之前，pi指向i,pj指向j。在调用ptrswap之后，pi指向j,而pj指向了i。

刘加加 2008-07-14 22:19 发表评论

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

刘加加 — Mon, 14 Jul 2008 13:48:00 GMT

使用引用形参的优点：

      在向函数传递大对象时，需要使用引用形参。虽然赋值实参对于内置数据类型的对象或者规模较小的类类型来说没有什么问题，但是对于大部分的类类型或者大型数组，它的效率就比较低了。另外，某些类类型是无法复制的。使用引用形参，函数可以直接访问实参对象，而无须复制它。

示例：
      bool isShorter(const string &str1,const string &str2)
      {
             return str1.size()      }
      由于string对象可能非常的长，我们希望避免复制操作。
      如果使用引用形参的唯一目的是避免复制形参，则应将形参定义为const引用。

使用引用形参应该注意的：

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

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

   所以，调用非const类型的引用形参，实参必须不是const类型的，而且实参的类型和形参的类型应当一致。

刘加加 2008-07-14 21:48 发表评论

使用引用形参返回额外的信息

刘加加 — Mon, 14 Jul 2008 04:12:00 GMT

      一个函数只能有一个返回值，但如果我想让他返回更多的信息怎么办呢？这种情况可以使用引用形参。
      因为引用形参在函数调用后是可以修改实参值的，所以就相当与函数的返回值。

      下面的代码演示了一个带有一个返回值，并通过引用形参向主调函数返回信息的函数。这个函数的功能是找出在容器中某一个数值出现的次数，并返回该数值第一次出现的迭代器。

//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()输入容器中的值
    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)
        {
            //这个if语句的作用是让res_iter等于值第一次出现的位置
            if(res_iter==end)
            {
                res_iter=beg;
            }
            occurs++;
        }
    }
    return res_iter;
}

刘加加 2008-07-14 12:12 发表评论

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

刘加加 — Sun, 13 Jul 2008 16:30:00 GMT

一、非引用形参

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

      这是最普通的形参方式，当函数被调用时，实参的副本初始化形参，函数并没有访问调用所传递的实参，因此v1+=1不会修改实参的值。对v1的操作只是修改了实参的一个副本。

二、指针形参

      void add2(int *p)
      {
          *p+=1;
          p+=1;
      }

      使用指针做为函数的形参，同样指针的值（指针的地址）不会因为p+=1而受到影响，但是指针指向的地址的值（*p）将会改变。所以要想修改实参的值，可以使用这种方法。但是还有一种更安全更自然的方法-引用形参

三、引用形参

      void swap(int &a,int &b)
      {
          int temp=a;
          a=b;
          b=temp;
       }

      引用形参直接关联到其所绑定的对象，而非这些对象的副本。所以这种方法可以修改实参的值，而且更加直观。

三种方法实例代码：

//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();
}

//非引用形参
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;
}

刘加加 2008-07-14 00:30 发表评论

创建和使用动态数组

刘加加 — Sat, 12 Jul 2008 15:26:00 GMT

      动态数组，顾名思义，就是可以动态分配长度的数组。在c语言中，数组的长度是固定的，而这种限制显然是很不灵活的。在c++中，数组有时候不用在编译时就知道长度，直到运行时才知道。与普通的数组变量不同，动态分配的数组将一直存在，直到程序显式的释放它为止。

定义：

      int *p=new int[20];

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

      同样上面的语句等同于：
      int n=20;
      int *p=new int[n];
      因为n是一个变量，所以数组的长度是动态的。

操作实例：

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

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

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

      这样就可以了，将他们输出：（这时指针p又指向了最后）

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

动态空间释放：

      最后重要的是别忘了将动态创造的空间释放掉，语句是：delete [] p;   ‘[ ]’表明该指针是指向的自由存储区的数组，而非单个对象。如果遗漏了空方括号，编译器将无法发现这个错误，将导致程序在运行时出错。

完成了！以下是完整代码：

#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();
}

刘加加 2008-07-12 23:26 发表评论

const和指针（指向const对象的指针、const指针）

刘加加 — Fri, 20 Jun 2008 16:13:00 GMT

1.指向const对象的指针

const int *p;
这个p是一个指向int类型const对象的指针，const限定了指针p所指向的类型，而并非p本身。也就是说p本身并不是const。在定义时不需要对它进行初始化，还可以给p重新赋值，使其指向另一个const对象。但不能通过p修改所指向对象的值。
示例1：int a=0; p=&a; 可以。
示例2：*p=20; 不可以。
结论：这种指向const对象的指针只是限制不能修改p指向对象的数值，而不是限制p指向什么对象。

把一个const对象的地址赋给一个不是指向const对象的指针也是不行的。
示例3：const int b=10;
int *p2=&b; //error
const int *p3=&b; //ok
结论：因为变量b有const修饰，不能被修改。但指针p2是一个普通的指针，可以修改指向对象的值，两种声明矛盾，所以不合法。而指向const对象的指针不允许修改指针指向对象的数值，所以这种方式合法。

2.const指针

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

指针p4称为const指针。它和指向const对象的指针恰好相反，它不能够修改所指向对象，但却能够修改指向对象的数值。另外，这种指针在声明时必须初始化。

3.指向const对象的const指针

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

指针dp既不能修改指向的对象，也不能修改只想对象的值。

刘加加 2008-06-21 00:13 发表评论

标准库 bitset 类型

刘加加 — Fri, 06 Jun 2008 15:04:00 GMT

有些程序要处理二进制有序集，每个位可能包含0值或者1值。位是保存一组项或条件yes/no信息的简洁方法。标准库提供的bitset类简化了位集的处理。使用bitset 类型，必须包含头文件：#include

bitset对象的定义和初始化

bitset b;               b有n位，每位都是0；
bitset b(u);           b是unsigned long型u的副本；
bitset b(s);            b是string对象s中含有的位串的副本；
bitset b(s,pos,n);   b是s中从位置pos开始的n个位的副本；

示例：
    bitset<16> bitvec1(0xffff);         //bitvec1的0-15位都是1
    bitset<32> bitvec2(0xffff);         //bitvec2的0-15为是1，16-31是0
    bitset<128> bitvec3(0xffff);      //bitvec3的0-15位是1，16-127都是0

    string str("1100");
    bitset<32> bitvec4(str);            //bitvec4的第2、第3位是1，其余都是0。因为string对象和bitset对象之间是反向转化的：string对象的最右边字符（即下标最大的那个字符）用来初始化bitset对象的低价位（即小标为0的位）

bitset对象的操作：

b.any()         b中是否存在置为1的二进制位？
b.none()       b中不存在置为1的二进制位吗？
b.count()      b中值为1的二进制位的个数
b.size()         b中二进制位的个数
b[pos]          访问b中在pos处的二进制位
b.test(pos)    b中在pos处的二进制位是否为1？
b.set()           把b中所有的二进制位都置为1
b.set(pos)      把b中在pos处的二进制位置为1
b.reset()        把b中所有的二进制位都置为0
b.reset(pos)    把b中在pos处的二进制位置为0
b.flip()            把b中所有二进制位逐位取反
b.flip(pos)      把b中在pos处的二进制位取反
b.to_ulong()   用b中同样的二进制位返回一个unsigned long值
os<

刘加加 2008-06-06 23:04 发表评论

迭代器 iterator

刘加加 — Fri, 06 Jun 2008 14:32:00 GMT

迭代器(iterator)是一中检查容器内元素并遍历元素的数据类型。

每种容器类型都定义了自己的迭代器类型，如vector:
vector::iterator iter;这条语句定义了一个名为iter的变量，它的数据类型是由vector定义的iterator类型。

使用迭代器读取vector中的每一个元素：
   vector ivec(10,1);

    for(vector::iterator iter=ivec.begin();iter!=ivec.end();++iter)
    {
        *iter=2;      //使用 * 访问迭代器所指向的元素
    }

const_iterator:
只能读取容器中的元素，而不能修改。
     for(vector::const_iterator citer=ivec.begin();citer!=ivec.end();citer++)
    {
        cout<<*citer;
        //*citer=3;   error
    }

vector::const_iterator 和 const vector::iterator的区别
    const vector::iterator newiter=ivec.begin();
    *newiter=11;   //可以修改指向容器的元素
    //newiter++;     //迭代器本身不能被修改

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

刘加加 2008-06-06 22:32 发表评论

认识标准库vector类型

刘加加 — Mon, 02 Jun 2008 15:48:00 GMT

vector是同一种类型的对象的集合，每个对象都有一个对应的整数索引值。和string对象一样，标准库将负责管理与存储元素相关的内存。我们把vector称之为容器。使用vector类型必须包含 include。
vector 是一个类模板(class template)。

vector的定义和初始化：
    vector text;            //保存类型为string的对象，默认构造函数text为空
    vector text2(10);   //保存类型为string的对象，包含10个空字符串
    vector ive(10,9);         //保存int的对象，保存10个值为9的整形变量
    vector ive2(ive);         //使用ive初始化ive2

向vector添加元素：
   while(cin>>word)
    {
        text.push_back(word);  //使用push_back可以向vector的后面插入新的元素。
    }
注意：*vector对象（以及其他标准库容器对象）的重要属性就在于可以在运行时高效的添加元素，因为vector增长效率高，在元素值已知的情况下，最好是动态的添加元素。
         *虽然可以对给定元素个数的vector对象预先分配内存，但更有效的方法是初始化一个空vector对象，然后再动态的增加元素。

vector的下标操作：
for(vector::size_type ix=0;ix!=text.size();++ix)
    {
        cout<[ix]<    }
*使用vector::size_type类型可以接收vector类型的大小。
*不在for循环之前取得vector的大小，而在for循环中计算text.size()，是因为vector是可以增长的，所以它的元素数目是不确定的。
*和string对象一样，vector可以通过下标直接访问元素。

附表：vector操作

v.empty()	如果v为空，则返回true
v.size()	返回v中元素的个数
v.push_back(t)	需按不过v的末尾增加一个值为t的元素
v[n]	返回v中位置为n的元素
v1=v2	吧v1的值与替换为v2中元素的副本
v1==v2	如果v1与v2相等，则返回true
!=,<,<=,>,>=	保持这些操作符惯有的含义

刘加加 2008-06-02 23:48 发表评论

c++字符处理 cctype

刘加加 — Sun, 01 Jun 2008 15:45:00 GMT

cctype头文件中定义的函数：

isalnum(c)	如果c是字母或数字，则为true
isalpah(c)	如果c是字母，则为true
iscntrl(c)	如果c是控制字符，则为true
isdigit(c)	如果c是数字，则为true
isgraph(c)	如果c不是空格，则为true
islower(c)	如果c是小写字母，则为true
isprint(c)	如果c是可打印的字符，则为true
ispunct(c)	如果c是标点符号，则为true
isspace(c)	如果c是空白字符，则为true
isupper(c)	如果c是大些字母，则为true
isxdigit(c)	如果c是十六进制数，则为true
tolower(c)	如果c是大写字母，则返回小写字母形式，否则返回c。
toupper(c)	如果c是小写字母，则返回大些字母形式，否则返回c。

刘加加 2008-06-01 23:45 发表评论

string对象的操作 size() empty() 关系运算赋值下标访问

刘加加 — Sun, 01 Jun 2008 15:22:00 GMT

string对象的操作：

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

获得字符串长度：
    int num=s.size();    使用整形接收字符串长度可能会有问题，因为int变量的表示范围太小，有时不能存储string对象的长度。使用string::size_type类型可以满足要求，这种类型是unsigned的，这比signed类型要大一倍。事实上size()函数返回的也是 size_type 类型。

关系运算：
可以使用：s1==s2；s1>s2；s1
赋值运算：
    string snew="empty";
    snew=s1;
上面代码首先初始化一个snew字符串，第二句将snew占用的内存释放掉，然后给snew足够存放s1副本的内存空间，最后把s1中所有的字符复制到新分配的内存空间。

字符串连接：
    cout<    cout<<"1"+s1<    cout<    cout<    //cout<<"hello"+"jiajia"<当进行string对象和字符串字面值混合连接操作时，+操作符的左右操作数必须至少有一个是string类型的。

通过下标访问string对象：
    string对象下标从0开始。
    for(string::size_type ix=0;ix    {
        s1[ix]+=ix;
    }

刘加加 2008-06-01 23:22 发表评论

字符串的读取 cin 和 getline()

刘加加 — Sat, 31 May 2008 16:02:00 GMT

cin
    string s;
    cout<<"Enter some words...";
    cin>>s;
    cout<<"You write:"<*读取并忽略开头所有的空白字符（空格、换行符、制表符）。
*读取字符直至遇到空白字符，读取终止。

getline()
    string line;
    cout<<"Enter a line...";
    getline(cin,line);
    cout<<"You write:"<*这个函数接收两个参数，第一个是输入流对象，第二个是string对象。
*getline不忽略行开头的换行符，只要getline()遇到换行符，哪怕是第一个字符，getline也将停止读取字符并返回。
*能够读取除换行之外的空白字符。

刘加加 2008-06-01 00:02 发表评论

c++初始化字符串的方式

刘加加 — Sat, 31 May 2008 15:48:00 GMT

C++初始化字符串的方式很灵活：

#include<iostream>
#include<string>
using namespace std;
int main(void)
{
    string s1;              //初始化为空字符串
    string s2("hello");     //初始化为一个字符串字面副本
    string s3(s2);          //将s3初始化为一个s2的副本
    string s4="hi jiajia";  //初始化为一个字符串字面副本
    string s5(15,'A');
    cout<<s1<<endl<<s2<<endl<<s3<<endl<<s4<<endl<<s5<<endl;
    system("pause");
    return 0;
}

注意：由于历史原因以及为了与C语言兼容，字符串字面值与标准库string类型不是同一种类型。

刘加加 2008-05-31 23:48 发表评论

命名空间的using声明

刘加加 — Sat, 31 May 2008 15:36:00 GMT

std::cout< : : 操作符是作用域解析符。它的含义是右操作数的名字可以在左操作数的作用域中找到。std::cout 的意思是说所需名字cin是在命名空间std中定义的。这种符号引用标准库名字的方式是非常麻烦的。
c++提供了一种简单的方式来使用命名空间成员，using声明。这是一种最安全的机制。

#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; //正确。指定了命名空间
    system("pause");
    return 0;
}

命名空间扩展：
在标准C++以前，都是用#include这样的写法的，因为要包含进来的头文件名就是iostream.h。标准C++引入了名字空间的概念，并把iostream等标准库中的东东封装到了std名字空间中，同时为了不与原来的头文件混淆，规定标准C++使用一套新的头文件，这套头文件的文件名后不加.h扩展名，如iostream、string等等，并且把原来C标准库的头文件也重新命名，如原来的string.h就改成cstring(就是把.h去掉，前面加上字母c)，所以头文件包含的写法也就变成了#include 。
并不是写了#include就必须用using namespace std;我们通常这样的写的原因是为了一下子把std名字空间的东东全部暴露到全局域中（就像是直接包含了iostream.h这种没有名字空间的头文件一样），使标准C++库用起来与传统的iostream.h一样方便。如果不用using namespace std;使用标准库时就得时时带上名字空间的全名，如std::cout << "hello" << std::endl;
#include "iostream"与#include的区别：前者先在当前目录找iostream文件，找不到再去系统头文件路径找，后者反之。因此，做为一个良好的习惯，在包含系统头文件时尽量用<>，而在包含自己的工程中的头文件时用""。

刘加加 2008-05-31 23:36 发表评论

开始学习c++语言

刘加加 — Sat, 31 May 2008 15:07:00 GMT

今天c语言的学习将告一段落。开始学习c++语言。
本来学习c就是为了学c++而准备的，但是感觉进度有点慢了，看了些基础的，准备学c++了。

对c++语言的学习，我将用那本经典的《C++ Primer》(中文版)。另外编辑器使用Dev-c++4.9.9.2。

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

刘加加 2008-05-31 23:07 发表评论

sprint() 格式化写入字符串

刘加加 — Fri, 30 May 2008 16:01:00 GMT

程序从读取用户输入的firstname,lastname和prize,并将他们读取的值按照一定格式存储到另一个字符串数组内。

#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;
}

刘加加 2008-05-31 00:01 发表评论

strcpy() 复制字符串

刘加加 — Fri, 30 May 2008 15:57:00 GMT

下面代码演示了程序循环从用户输入读取字符串，并存入临时的字符串数组，然后将临时字符串复制到qwords数组里面。

#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;
}

刘加加 2008-05-30 23:57 发表评论

strcmp() 比较字符串的内容

刘加加 — Fri, 30 May 2008 15:48:00 GMT

下面程序使用strcmp()验证答案是否正确：

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

下面程序说明各种情况下，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"));

刘加加 2008-05-30 23:48 发表评论

strcat()函数

刘加加 — Tue, 27 May 2008 12:12:00 GMT

strcat()接受两个字符串参数。将第二个字符串的一份拷贝添加到第一个字符串的结尾，从而使第一个字符串成为一个新的组合字符串，第二个字符串不改变。

#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;
}

以上程序将string2字符串的拷贝放到了string1的结尾。

值得注意的是，string1在被使用strcat()函数之前，应该是已经初始化或者已经存储了一个字符串。因为如果字符串没有被初始化，string1[]里面元素的存储是一串随机值。strcat()需要找到string1的结尾（第一个出现的'\0'）,然后去掉这个'0',最后把string2[]的拷贝放到string1[]最后一个值的后面。

刘加加 2008-05-27 20:12 发表评论

使用strlen()获得字符串长度

刘加加 — Tue, 27 May 2008 11:32:00 GMT

函数原型：size_t strlen(const char*)
作用：返回参数中字符串的长度。

以下代码是一个截取字符串的例子：

#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';
    }
}

截取前：

space

截取后

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

刘加加 2008-05-27 19:32 发表评论

字符串的输入和输出（认识gets()fgets()scanf()和puts()fputs()printf()）

刘加加 — 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);
它使用一个地址把字符串赋予name。

    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 关键字返回字符串的地址，程序把这个地址分配给指针p。

fgets()
fgets()是为文件I/O而设计的，处理键盘输入不是特别方便。

    printf("\nHi,What's your name?\n");
    p=fgets(name,20,stdin);
    printf("%s?Oh,Nice name %s\n",name,p);
*fgets()的第二个参数说明最大读入的字符数。如果这个参数值为n，那么fgets()就会读取最多n-1个字符或读完一个换行符为止。两个条件满足任意一个结束。
*fgets()读取到换行符，就会把它存到字符串里，而不是想gets()那样丢弃它。
*fgets()的第三个参数说明读哪个文件。从键盘上读数据时，可以使用stdin(代表standard input)作为参数。

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()允许指定输入字符串长度等格式。上面的程序如果输入"liujiajia liujiajia",程序将输出"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()显示字符串时自动在其后添加一个换行符。
puts(&str[5]);将输出从str的第六个元素开始到字符串结束。
puts(str2+2);将输出从str2的地址向后移动两个字符开始到字符串结束。

fputs()
    fputs(str,stdout);
    fputs(str2,stdout);
    fputs(&str[5],stdout);
    fputs(str2+2,stdout);
*fputs()第二个参数表示要写的文件。可以使用stdout(代表standard output)作为参数。
*fputs()不自动输出换行符，这与puts()不太相同。

printf()
这个不用多说了。

刘加加 2008-05-27 18:03 发表评论

初步认识数组、指针和字符串关系

刘加加 — Fri, 23 May 2008 16:27:00 GMT

字符串数组初始化：
(1)char arr[10]="HI";
初始化字符串数组时，编译器自动将字符串最后一个字符后面加上'\0',以表示字符串的结束。
如果数组的大小大于字符串的长度+1，那么把字符串结束后面的元素也都初始化为'\0';
看这段程序：
定义一个大小为12的字符串数组
char str1[12]="jiajia";
让一个char型的指针指向这个数组
    char *p1=str1;
输出这个字符串
    printf("%s\n\n",str1);
利用指针输出这个字符串数组中每个元素的字符、字符ascii值、字符存储地址
    for(int i=0;i<12;i++)
    {
        printf("%c:%d:%p\n",*p1,*p1,p1);
        p1++;
    }
可以看出，数组元素的后几位都被初始化成了'\0';使用printf打印字符串数组时，程序遇到第一个'\0'就结束对字符串的读取。

如果数组的大小小于字符串的长度+1，程序在运行时可能要出现问题，所以应当确保数组的大小要大于字符串长度的大小+1；

这段程序的字符串长度+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打印字符串，程序需要找到'\0'才能结束读取，结果找遍整个数组没有找到，只有继续顺着地址寻找，一直找到某个地址上的assii是0的，字符串才读取完毕。所以本段程序在读取完"hello jiajia"之后，后面可能还会有几个随机的字符，就是因为字符串终止于'\0'。

(2)char arr[]="Hello World!";
这种初始化方法不用担心数组大小过小的情况，数组的大小由编译器决定。
(3)char arr[]={'H','e','e','l','o',' ','W','o','r','l','d','\0'};
同第二种方法结果相同，但显然要麻烦许多。另外，' '代表空格，ascii值是32，'\0'代表字符串结束，ascii值是0；
(4)char *p="Hello World";
使用数组的方式初始化。同数组不同之处在于,p是一个变量，可以做递增、递减运算，而arr是数组的首地址，是一个地址常量，不能做递增、递减运算。

char *name="liujiajia";
    name[0]='L';
    printf("\n%s\n",name);
name[0]='L';这句代码在最新的c99标准中会引发程序异常。需要注意。

char *string="c programe";
    char *string2;
    string2=string;    //将指针string的值赋给string2

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

上面这段程序最后显示，指针string所指向的地址和指针string2所指向的地址相同，这就说明它们指向的是内存里面同一个字符串，也就是说字符串本身并没有复制，而是产生了一个指向同一个字符串的指针。这样程序的效率会更加的高。如果需要复制字符串可以使用 strcpy() 或 strncpy()。

刘加加 2008-05-24 00:27 发表评论

函数和二维数组的新认识(参数指定数组第二维和第一维大小)

刘加加 — 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);//求出每行的数值总和。

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

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

#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;
}

运行后发现，程序报错了，这是为什么呢？百思不得其解，后来请教了CSDN上老大们。终于稍微弄明白了点儿。我想具体应该从两方面证明为什么上面的程序不可行。
（1）从二维数组的存储方式上：二维数组在内存上是一行一行连续的存储的。如下图：
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是这个数组的首地址，我们可以知道arr[0][0]的地址。只要我们知道arr[][4]中数组第二维的大小‘4’，我们就可以找到任意行和列的地址。address=arr+(rows-1)*4+cols。但是如果不知道第二维的大小，那么条件就不够了。打一个比方，将若干个学生分成每组11人，并让他们站成一排，这时我们可以定位出第几组的第几个学生。但如果不知道每组11个人，那么我们显然就无法定位了。

（2）从指针的角度上看(这种思路我还是有点迷糊):大家可以参看这个帖子：http://topic.csdn.net/u/20080520/09/2122e210-5cf5-4b75-b31f-c2523b00cf53.html?575319732

恩，现在是越学越迷惑了。呵呵。

刘加加 2008-05-20 22:31 发表评论

函数和二维数组

刘加加 — Mon, 19 May 2008 15:03:00 GMT

阅读下面代码，程序列举了3种二维数组作为参数传递的方法：

#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);   //另一种语法形式
int main(void)
{
    int junk[ROWS][COLS]={{1,2,3,4},{5,6,7,8},{9,10,11,12}};

    sum_rows(junk,ROWS);//求出每行的数值总和。
    printf("\n");       //求出每列的数值总和。
    sum_cols(junk,ROWS);//求出全部数值的总和。

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

刘加加 2008-05-19 23:03 发表评论

指针和多维数组

刘加加 — Mon, 19 May 2008 14:28:00 GMT

一、多维数组地址和指针的关系
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)

上面的程序的结果输出竟然都一样。为什么呢？
首先 arr2 代表的是arr2数组的首地址，所以 arr2的值和 arr2第一个子元素arr2[0]的地址相同，即 &arr2[0]；
arr2[0]是含有两个整形元素一维数组的首地址，即&arr2[0][0]的值。
简单的说：arr[0]是一个整数大小对象的地址，arr2是两个整数大小对象的地址。因为整数和两个整数组成的数组开始于同一个地址，所以 arr2 和 arr2[0] 具有相同的数值。

二、指针（地址）运算和多维数组的关系
printf("arr2+1=%p,arr2[0]+1=%p\n",arr2+1,arr2[0]+1);
现在我们知道，arr2 和 arr2[0]具有相同的数值，但是arr2+1和arr2[0]+1为什么数值不一样呢？这是因为，arr2指向的对象大小是两个int，儿arr2[0]所指向的大小是一个int。所以arr2+1的值要比arr2[0]+1的值多一个int大小。

三、使用*对多维数组取值
因为 arr2[0] 是 arr2[0][0]的首地址，所以 *(arr2[0])代表存储在arr2[0][0]的值。同样，arr2是arr2[0]的首地址，*arr就是 arr2[0]的值。但是 arr2[0]也是一个地址，即&arr2[0][0],因此*arr2是 &arr2[0][0]。所以 *&arr2[0][0] 等价于 **arr2。*&arr2[0][0] 可以简化为 arr2[0][0]。所以 arr2[0][0]==**arr2。
简而言之：arr2是地址的地址，所以需要经过两次取值才能取到具体的数值。

学完这个知识点，才发现在指针确实很难懂。

刘加加 2008-05-19 22:28 发表评论

指针的基本运算

刘加加 — Mon, 19 May 2008 11:08:00 GMT

对指针可以进行赋值、求值或取值、取指针的地址、将一个指针加上一个整数、增加指针的值、求差值的操作。请参看以下代码展示了几种情形：

#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]的地址，并赋给一个指针

    printf("数组各个元素的值和地址：\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!=指针，指针+int==地址)：\n");
    printf("p1+4=%p,*(p1+4)=%d",p1+4,*(p1+4));

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

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

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

    getchar();
    return 0;
}

刘加加 2008-05-19 19:08 发表评论

带有数组类型参数的函数

刘加加 — Fri, 16 May 2008 15:54:00 GMT

传递数组参数，其核心就是传递该数组的首地址。然后函数再通过数组、指针等，用该数组的首地址构造一个新的数组或指针，再通过传递过来的数组大小，对该数组进行操作。

#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;
}

以上代码演示怎样定义有数组作为参数的函数。
如果数组作为参数传递进入某个函数，并且在这个函数中改变了数组元素的值，那么程序返回后，这个数组元素的值有没有改变呢？

当然，值改变了，因为数组是通过地址传递的，改变了被调函数中数组的值也就意味着同时改变了主调函数中数组的值。因为它们的地址是相同的。

刘加加 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;

以上代码展示了读取数组中元素的两种方式，第一种是常规的使用数组下标来读取。第二种方法是使用指针来读取数组。

通过第一中方法中打印出来的内容，我们可以认识到，数组名其实就是这个数组的首地址，即：arr=数组首地址;arr+1:数组第二个元素的地址；arr+2：数组第三个元素的地址，以此类推。。。

第二种方法我们使用指针访问代替了数组下标访问，我们将 arr(即数组的首地址)赋值给了指针 *p，所以 p就等于arr的首地址，p+1就等于arr的二个元素的地址，那么*p就相当于了arr[0],*(p+1)就相当于arr[1]。

我们从中可以得出一个结论：数组标记实际上是一种变相使用指针的形式。

刘加加 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)
{
    //将4名球员近三场比赛的得分初始化
    int arrmark[MATCH][PLAYER]={
        {9,8,7,5},
        {8,10,8,7},
        {7,7,10,6}
        };
    //输出具体成绩
    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");
    }
    //打印总分
    int temp=0;
    printf("total        ");
    for(i=0;i<PLAYER;i++)   //求每个球员的总分
    {
        for(j=0;j<MATCH;j++)
        {
            temp+=arrmark[j][i];
        }
        printf("%d      ",temp);
        temp=0;
    }
    getchar();
}

刘加加 2008-05-16 00:06 发表评论

指定数组大小

刘加加 — Thu, 15 May 2008 15:32:00 GMT

指定数组大小也有很多方式：
    char arr[10];                                    //OK
    char arr2[1+2*7];                            //OK
    char arr3[sizeof(char)+2];                //OK
    char arr4[-2];                                  //error 数组大小不能使用负数
    char arr5[0];                                   //根据编译器不同，有的编译器转换为“arr5[]”,有的编译不通过。
    char arr6[3.14];                            //error
    char arr7[(int)3.14];                       //强制转换为int
    int m=2;
    char arr9[m];                                //c99前不允许

注意：c99标准允许使用变量指定数组大小。

刘加加 2008-05-15 23:32 发表评论

认识数组之数组的初始化

刘加加 — Thu, 15 May 2008 15:11:00 GMT

以下代码展示数组初始化的各种情况：

#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]);
    }

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

    //数组不初始化，元素的值为随机数。
    int arr3[SIZE];
    for(index=0;index<SIZE;index++)
    {
        printf("arr3[%d]=%d\n",index,arr3[index]);
    }

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

    //数组的元素个数不固定
    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;
}

程序运行结果是：

怎么样？数组的初始化方式多种多样。但要灵活运用。

刘加加 2008-05-15 23:11 发表评论

认识sizeof

刘加加 — Thu, 15 May 2008 08:01:00 GMT

sizeof 是C语言里面的一个运算符，并且以字节为单位返回其操作数的大小。操作数可以使一个具体的数据对象、变量类型、一个操作数。并且返回类型为size_t，size_t是在stddef.h头文件里定义的，原型是：typedef unsigned int size_t;
以下代码演示sizeof用法：

#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写法错误！
    printf("sizeof(char)=%d\n",sizeof(char));
    printf("sizeof(float)=%d\n",sizeof(float));
    printf("sizeof(double)=%d\n",sizeof(double));

    return 0;
}

运行结果显示：

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

刘加加 2008-05-15 16:01 发表评论

使用igoogle

刘加加 — Wed, 14 May 2008 16:00:00 GMT

大家有没有用过google的自定义主页，就是 igoogle 。可以自己添加google为你提供的小工具来组成你的主页。里面有个google眼睛，感觉很好玩。
可是我同时想把我一些常用的链接放进去，但是igoogle并没有提供相关的工具，怎么办？没关系，google为你提供了小工具开发的接口。

1.进入 igoogle 。
2.点击“添加内容”链接。
3.点击“添加供稿源或小工具”，输入‘http://helloliukai.googlepages.com/hi.xml’ 点击添加。
4.然后回到首页，你可以看到你的igoogle主页上添加了一个名为‘hello world example’的小工具。

呵呵，你只要打开http://helloliukai.googlepages.com/hi.xml 这个xml文件就会发现其中的问题了。
igoogle通过解析xml文件来向用户展示小工具。你只要把“”中的“Hello, world!”替换成任意html或javascript代码就行了。然后把修改过的xml文件上传到一个公共的空间里面就行了。我用的同样是google的产品，Page Creator：http://pages.google.com/ 。呵呵。google的东东确实很多。
另外，xml确实也很强大。

http://code.google.com/intl/zh-CN/apis/gadgets/ 这里有google的资源，有教程和小编辑器。但教程感觉已经过期了，好多里面的代码都不能用。可以使用那个小编辑器打开各种模板。

刘加加 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()调用了自己
    }
    printf("2Lv%d:%p\n",n,&n);
}

以上是一个递归的示例。
testfunc()在内部调用了自己，这样的后果是：暂时不执行最后面的“printf("2Lv%d:%p\n",n,&n);”，而是将 n+1作为参数调用了自己，这样重复，最终程序的结果是：

(根据电脑不同，地址可能有所不同)
程序具体运行步骤：
1.main()调用testfunc(1)
2.testfunc(1)执行，打印“lv1:0022FF60”，0022FF60是n的地址
3.n<4,条件成立， testfunc(1)调用testfunc(2)
4.testfunc(2)执行，打印“lv1:0022FF40”,因为此时testfunc(2)的变量n已经不是testfunc(1)中的变量n了，所以地址不同。（函数的参数作用域只在当前函数）
5.n<4，条件成立，testfunc(2)调用testfunc(3)
6.testfunc(3)执行，打印“lv1:0022FF20”
7.n<4，条件成立，testfunc(3)调用testfunc(4)
8.testfunc(4)执行，打印“lv1:0022FF00”
9.n<4,条件不成立，打印“2lv1:0022FF00”
10.返回调用testfunc(4)的testfunc(3),打印“2lv1:0022FF20”
11.返回调用testfunc(3)的testfunc(2),打印“2lv1:0022FF40”
12.返回调用testfunc(2)的testfunc(1),打印“2lv1:0022FF60”

OK,这就是函数的递归调用，通俗的说就是函数自己调用自己。以前学时没有弄明白，现在终于弄明白了。

刘加加 2008-05-14 00:08 发表评论

认识getchar()和putchar()

刘加加 — Fri, 09 May 2008 14:55:00 GMT

getchar()函数没有参数，返回输入设备的下一个字符。
ch=getchar(); 和 scanf("%c",&ch);是同样的效果。

putchar()函数用来打印它的参数。
putchar(ch); 和 printf("%c",ch); 是同样的效果。

这两个函数都在 stdio.h 文件中定义了。

刘加加 2008-05-09 22:55 发表评论