C++博客-刘加加在成长(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 发表评论

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 发表评论