C++[转]C++语法概括及其示例(示例代码下载)

正文转自:http://blog.csdn.net/ChengKing/archive/2005/11/06/524112.aspx
原稿如下:
章多少不着边际的地点提供了代码示例,点击链接下载:

http://www.cnitblog.com/Files/ChengKing/**c++相关示例.rar**

(含200单上示例)

1.              I/O流的常用控制符
              dec                         置基数为10
              hex                         置基数为16
              oct                         置基数为8
              setfill(c)                  设填充字符为C
              setprecision(n)             设显示小数精度也n位
              setw(n)                     设域宽为N个字符
              setiosflags(ios::fixed)     固定的符点突显
              setiosflags(ios::scientific)指数表示
              setiosflags(ios::left)      左对齐
              setiosflags(ios::right)     右对齐
              setiosflags(ios::skipws)    忽略前导空白
              setiosflags(ios::uppercase) 16前进制数大写输出
              setiosflags(ios::lowercase) 6进制数小写输出  
              setiosflags(ios::showpoint) 彰显小数点
              setiosflags(ios::showpos)   正数前面加上正号
2.头文件:*iostream.h*    *iomanip.h*   *stdlib.h*
           cout/cin   流的决定符  exit(0)      
3.指针的几乎种档次:
  int (*p)();p为指向函数的指针变量,该函数带回一个整形值
  int *p();p为带回一个指南针的函数,该指针指于整形数据
  int
(**)[n]p为一个对一个指针变量的指针变量,被指向的指针变量指向一个含n单整形数据的平维数组
4.构造函数和析构函数特点及其区别:
  
a.构造函数可以生出擅自独形参,还是可以够重载(多独参数个数不同之函数);但析构函数不可知暴发形参,因为是系统活动调用的.
  
b.构造函数不得以随心所欲调用,只照系统调用;而析构函数不仅系统调用,也足以任意调用.                               
5.构造函数和析构函数啥时候自动运行?(例61)
          构造函数:一般以定义类对象时自动运行.
         
析构函数:尽管一个函数中定义了一个目的,则于是函数运行了时即执行同样潮;
                  
当一个对象是行使NEW运算符被动态创设的,在动用DELETE运算符释放它平时,DELETE将会晤自行调用析构函数.
          拷贝伊始化构造函数:当用tpoint N(M);语句时调用相同次于;
                        
当对象作为实参向形参传递时,即对形参起始化时实施同样软;
                        
当际遇M=return(N);语句,即对M举办先河化时调用一赖;

6.this 指针用法:例63中,当程序执行语句list
elem(i);时,系统针对this指针举办了如下的缺省赋值:this=&list;
                赋值成员函数举例(此例在例63基础及):
                      void Assign(linear_list&);//表明语句;
                      void linear_list::Assign(linear_list&p)
                       {if(&p==this)
                           return;
                        nmax=p.nmax;
                        nelem=p.nelem;
                        list=new int[nmax];
                        for(int i=0;i<nmax;i++)
                           list[i]=p.list[i];
                       }  
7.const,volatile对象以及const,volatile成员函数
  格式:const person per/volatile person per;                       
       int func(int) const;/char func(int) volatile;
  表达:1.司空见惯对象既好拜const对象,又有何不可看volatile对象;
       2.const目标只雅观用const修饰的积极分子函数;
         volatile对象只能看用其所长volatile修饰的积极分子函数;
       3.吗得以以证实也const volatile对象或const volatile成员函数;
         const volatile对象只赏心悦目const volatile成员函数;
         const/volatile对象啊能看const volatile成员函数;
8.不同继承格局的基类和派生类特性
  ————————————————
   继承模式      |   基类特性        |  派生类特性
  ————————————————
                 |   public          |  public
   公有继承      |   protected       |  protected
                 |   private         |  不可看
  ————————————————
                 |   public          |  private
   私有继承      |   protected       |  private
                 |   private         |  不可看  
  ————————————————
                 |   public          |  protected
   珍爱持续      |   protected       |  protected
                 |   private         |  不可看
  ————————————————
  A:帮忙精晓:1)对于国有继承形式:
              
a.基类成员对该目的的可见性:公有成员可见,其他不可见。这里爱惜成员和受民用成员。
              
b.基类成员对派生类的可见性:公有成员和保安成员可见,而个人成员不可见。这里爱护成员及于国有成员。
              
c.基类成员对派生类对象的可见性:公有成员可见,其他成员不可见。
           
所以,在国有继承时,派生类的目的足以看基类中之公有成员;派生类的积极分子函数可以拜基类中之公有成员与保安成员。这里,一定要是分别清楚派生类的指标及派生类中之积极分子函数对基类的走访是例外的。
            2) 对于私有继承形式:
               a.基类成员对其目的的可见性: 公有成员可见,其他不可见。
              
b.基类成员对派生类的可见性:公有成员及保障成员可见,而个人成员不可见      
               c.基类成员对派生类对象的可见性:所有成员依旧不可见的。
           
所以,在个体继承时,基类的成员只好出于直接派生类访问,而一筹莫展还往下持续。
            3) 对于保障持续格局:
              
与私家继承形式同样,两者的分别仅在针对派生类的成员而言,对基类成员暴发异的可见性。
 B:匡助精晓:1)
公有继承时,水平访问与直访问对基类中的公有成员不给限制。
             2)
私有继续时,水平访问同垂直访问对基类中的国有成员为无可知访问。
             3)
敬爱持续时,对于直访问和于国有继承,对于水平访问同深受个人继承。
             4)
对于基类中之个人成员,只可以被基类中的成员函数和友元函数访问,不克于另外的函数访问。
 C:协助精晓:在国有继承时,派生类的分子函数可看基类中之公有成员和护卫成员;派生类的对象就可看基类中之国有成员。
9.派生类的构造函数和析构函数:
     派构:
         1.形似格式: 派生类名 
(派生类构造函数总参数表):基类构造函数(参数表1),子对象名(参数表2)
                          {派生类中数量成员开头化};
         2.调用顺序:
a.基类的构造函数。b.子对象类的构造函数(即便有些话).
c.派生类构造函数。                         
10.多后续:是凭派生类有多单基类。
   多继承的构造函数:
                  
《派生类名》(总参数表):《基类名1》(参数表1),《基类名2》(参数表2),…
                       {派生类构造函数体}  
11.虚基类:假使基类被声称也虚基类,则再次继承的基类在派生磁对象实例中不得不存储一个副本,否则,将应运而生多独基类成员副本。
   虚基类表达格式如下:  virtual<继承形式><基类名>
                         class B:virtual public A
 
注意:a.假若一个派生类有直接或者直接的虚基类,那么差生类的构造函数的成员开始列表中得列有对虚基类的调用,假若非受列有,则表示用该基类的缺省构造函数来起头化派生类对象被之虚基类子对象。
        b.虚基类的构造函数先于非虚基类的构造函数调用。
       
c.只出树立目的的那么个派出生类的构造函数调用虚基类的构造函数,而该派生类的基类中所列有之对准这虚基类的构造函数的调用在实践着于忽略。   
12.运算是符重载:
      operator 函数用法:(无法发生下列字符:’::’,’.’,’*’,’->’,’? :’)
          1.一般:int class_name::operator <运算符> (形参列表)  
(例92)
          2.增量减量运算符:   (例93,94,95,96)
               a.将一个增量运算符重载为坐的成员函数:
                           int class_name::operator++();
               b.将一个增量运算符重载为后置的成员函数:
                           int class name::operator++(int);
               c.将一个增量运算符重载为坐的友元函数:
                           int operator ++(class_name&);         
               d.将一个增量运算符重载为坐的友元函数:
                           int operator ++(class_name&,int);     
               e.下标运算符:
                           int class_name::operator[](形参) 
//只好是非静态成员函数                          
               f.函数调用运算符: 
                           int
class_name::operator()(形参表)//只好是非静态函数,且非得以涵盖缺省的参数
               g.成员选用运算符:
                           class_name $/*
class_name::operator->();
               h.new delete运算符:
                           void *class_name::operator
new(siz_t,<arg_list>);
                           void *class_name::operator delete(void
*,<size_t>);
                   new
delete只好让重载为类的分子函数,不可知是友元。而且不管是否用紧要字static
                   举行修饰,重载了之new和delete均为接近的表态成员函数。
                       对于typedef unsigned size_t;
                  
在头文件alloc.h,mem.h,stddef.h,stdio.h,stdlib.h均注脚;
               i.友元函数:
                      
可以是一个接近的非静态函数,也得以是类似的友元函数。
                      {friend complex operator+(complex&,complex&);
                      }; 
                 以下五种植运算符不表明成友元运算符:
                      “=”,”()”,”[]”,”->”,”type”; 
               j.转换函数:
                         class_name::operator type();  //type
是其它一个官的C++的档次名(包括主旨数据类及导出数据类型)以及由于要字const和volatile引出的达示。)
                                                      
//不牵动任何参数,也随便重回值类型,总是回到type的价值。只可以是近乎的积极分子函数,不可知征呢友元运算符。
               k.类的赋值运算和运算符重载:
                         person & person::operator=(person &p)
                           {dele Name;
                            Name=new char[strlen(p.Name)+1];
                            strcpy(Name,p.Name);
                            Age=p.Age;
                            Sex=p.Sex;
                            return *this;
                           }
                       
典型例题。当用系统自带对象赋值的函数,如若目标里似 *Name
型的,则赋值后会师如个别单指针同时对一个分子元素的地址,当调用析构函数放时,会放两不良,多放一不良,而起错误,这多少个非凡例题是用来把一个分子元素复制到其它一个对象吃,不是单独移动指针,当调用析构函数时,会放出两涂鸦。
               l.重载函数:系统才对形出席以界别。
13.虚函数
    
一般景观下,指向一个靶的指针,不允对任何一个对象,但针对基类对象的指针可以对她的派生类,并可看派生类中原基类成员。
    
假诺一个函数一旦申明呢虚函数,则凭表达其的类为接续了不怎么层,在各级一样重叠中该函数都保持该virturl特性。且可于派生类中对该函数省略virtual.
    
虚函数必须是近乎的一个分子函数,无法是友元,但其能够是任何一个像样的友元。虚函数不可知是一个静态成员。
     设定绑定形式,使程序有所灵活性,但履效率不如,占用内存多.    
14.虚幻类:纯虚函数
      纯虚函数的一般式吗:virturl
类型名(参数表)=0;抽象类不可知报名对象。
15.类属于结构:
       1.函数模板:template <class 模板形参表>                
                重返值类型 函数称为(模板函数形参表)
                  {
                   函数体;
                  }
             example:
                 template  <class T>
                 void swap(T &.x,T&.y)
                  {T t;
                   t=x;x=y;y=t;
                  }
       2.还载函数模板:调用用次序:
            1)寻找一个通通匹配的函数,找到,调用的。
           
2)寻找一个函数模板,将其实例化发生一个配合的模板函数,找到,调用的。
           
3)寻找重载函数中生出无通过类型转换后发生参数匹配的函数,若有,调用的。
       3.类模板:template <class 模板形参>
                 class 类模板名
                 {
                  类体;
                 }
             example:  tempplate <class T>
                       class stack
                       {private:
                          T *date; 
                          int top;
                        public:
                          isempty();
                       }
                       template <class T>
                       {…}  
16.类模板的友元:
          a.一般的类模板友元函数。
         
b.封闭型的类模板友元函数。当用种参数将类似模板实例化为某个具体的模版类时,该类模板所蕴藏的友元函数也用继实例化。
          c.开放型的好像模板友元函数。
       例一百二十一。
17.C++的I/O流库
    1.  I/O标准流类  
        —————————————–
        c++名字  |  设备  | C中的名 | 默认的义
        —————————————–
        cin      |  键盘  | stdin     | 标准输入
        —————————————–
        cout     |  屏幕  | stdout    | 标准输出
        —————————————–
        cerr     |  屏幕  | stderr    | 标准错误
        —————————————–
        clog     | 打印机 | stdprn    |  打印机
        —————————————–
     2。键盘输入
        cin>>a>>b>>c;  //Ctrl+z终止
        cin.get(char &ch)//从输入流得一个字符,不忽视空格Ctrl+z终止
        cout.put(ch)//输出一个字符       
    EOF//其值为-1,至极给已符 
        cin.geline(char *buf,int
limit,Deline=’\n’)//buf为一个指针或频繁组,limit为字符个数,Deline为念博字符指定了符。效能:从键盘读入一差字符。停止用Ctrl+z.
    cin.gcount()//重返getline()刚刚读了的字符个数 
        cin.read(char *buf,int size)//读入指定数量的字符
    cout.write(const char *str,int
n)//cout.write(“string”,strlen(“string”);则输出全体字符。
    cin.peek()//再次回到输入流的下一个字符,不过非领取它。
    long(a)//a可以是指针地址,功效,强制转换为什进制数。
    (void*)//ex:char
str=”abcde”;cout<<str;将str为首地址字符串的首地址输出。   
18.输入符,提取符重载:<<  >>
     例154
155例题                             
19.磁盘文件之输入。头文件#include”fstream.h”  //例题从156开始
    1.开辟文件:
         a.   fstream outfile;
             
outfile.open(“f1.txt”,ios::out);//其中fstream为系统针对文件专用操作类
         b.   ofstream ostream(“f1.txt”);
              ofstream ostrm; 
ostrm.open(“f1.txt”);//表示打开某个写文件
         c.   ifstream istrm(“f2.txt”);
              ifstream istrm; 
istrm.open(“f2.txt”);//表示打开某个读文件

     

                  方式名              |            用途

     

                   in                 |         以输入情势打开文件

     

                   out                |         以出口格局打开文件
     
———————————————————————–  
            app                |         以出口追加格局打开文件

     

                  ate                |        
文件打开时,文件指针位于文件尾

     

                   trunc              | 
尽管文件是,将该长截断为零星,并免去所有情节,假若文件未存在,则开立异文件

     

                   binarg             |  
以二进制格局打开文件,缺省时也文本模式

     

                   nocreate          
|打开一个就发文件,如该文件不在,则打开退步

     

                   noreplace          |假诺文件是,除非设置
ios::ate或ios::app,否则打开失利

     

                   ios::in |ios::out  |以朗诵与描写的措施打开文件

     

                 ios::out|ios::binary |以二进制形式打开文件

     

                 ios::in|ios::binary  |以二进制情势打开文件

     

    2. 闭馆文件:
              fstream outfile;
              outfile.close();  
    3. 开辟文件战败退出程序:用函数abort();退出,在头文件<stdlib.h”
    4.判断文件截止函数.example:  infile.eof()
    5.getline(char*,sizeof(s));//读取一弄错字符
      get()/put()//对文本字符操作,例如outfile.get  
    6.随机访问数据文件:
        1)读指针
          istream &istream::seekg(流中地点)//
          istream
&istream::seekg(偏移量,参照地点)//参照地方分为:cur=1/beg=0/end=2 
input.seekg(-100,ios::cur);
          streampos
istream::tellg();//其中streampos定义也long型,它回到一个long型且值为当前指针离文件先导的岗位(字节数)
        2)写指针
          ostream &ostream::seekp(流中的职)
          ostream &ostream::seekp(偏移量,参照位置)//参照地方与齐
          streampos ostream::tellp();
    
注意:读函数中生出get(),写函数着生put(),操作读指针用seekg(),而写指针用seekp();write()和read()中之率先只参数必须也(char
*),即便未是,一定假使强制转换
    7.  while(!cin);//表示输入流发生错。
        cin.clear();//原型 void
ios::clear(int=0);其用途是将左状态的标志字中错误标志位清除,重新判断输入。
       
cin.ignor(80,ch);//如果ch=’\n’,一般代表忽略一行,重新到下一行去输入
        istream &istream::ignore(int n=1,int
t=EOF);//跳了输入流中指定数量的字符的函数,t为终止符,一般EOF非常给<ctrl+z>操作
        istream &istream::pubback(char
ch)//退回一个字符到输入流的函数,其中ch是指出要退输入流的字符。

  1. 格式化输入和输出:        例题从 167方始
         A.设置流的格式化标志
            1).控制格式的标志位
            

           标志位 |   值   |                           
含义               |输入/输出

        

          skipws  | 0x0001 |                
跳了输入被之空域符                 |    i

        

           left   | 0x0002 |                
输出数据失实对齐                     |    o

        

          rignt   | 0x0004 |                
输出数据下手对齐                     |    o

        

         internal | 0x0008 |  
数据的号左对共同,数据本身右对一起,之间为填符   |    o

        

           dec    | 0x0010 |             
转换基数为十进制模式                  |   i/o

        

           oct    | 0x0020 |             
转换基数为八进制格局                  |   i/o

        

           hex    | 0x0040 |            
转换基数为十六进制形式                 |   i/o

        

         showbase | 0x0080 |               
输出数据前发0/0x                    |    o

        

        showpoint | 0x0100 |             
浮点数输出带有小数点                  |    o

        

        uppercase | 0x0200 |          
用大写字母输出十六进制数值               |    o

        

         showpos  | 0x0400 |              
正数前边有“+”号                    |    o

        

        scientfic | 0x0800 |           
浮点数输出使对表示法                |    o

        

          fixed   | 0x1000 |           
使用定点数模式表示浮点数                |    o

        

         unitbuf  | 0x2000 |       
完成输入操作后即刷新流的缓冲区            |    o

        

          stdio   | 0x4000 |        
完成输入操作后刷新系统的stdout             |    o
        
——————————————————————————    
       2).使用成员函数设置标志字:
           1.long flags()       //该函数用来回到标志字
           2.long flags(long)  
//该函数使用参数更新标志字,重回更新前的标志字
           3.long setf(long setbits,long
field)//将field所指定的标志清零,将setbits为1底职位1,重回往日的标志字
           4.long setf(long) 
//设置参数所指定的这一个标志的各,重返更新前的标志字
           5.long
unsetf(long)//该函数用来解参数所指定的这多少个标志位之各,再次来到更新前之标志字
        在ios类吃,定义了底的表态类对象;
           static const long  basefield; //其值为dec/oct/hex
           static const long adjustfield //其值为left/right/internal
           static const long  floatfield //其值为scientific/fixed
        example:  cin.setf(ios::dec,ios::basefield      
    B.格式输出函数:
       1).设置输出数据所占宽度的函数
           1.int width()//该函数重返时出口数据的小幅
           2.int
width(int)//刻函数用来安装当前出口数据的肥瘦为参数值,并回到更新前的宽值
       2).填充当前增幅内的填充充字符函数
           1.char fill()//该函数用来回到时所下的填充字符
           2.char
fill(char)//该函数用来装填充字符为参数值所表示的字符,并返更新前之填充充字符
       3).设置浮点数输出精度函数
           1.int precision()//该函数重回时浮点数的可行数字之个数
           2.int
precision(int)//该函数设置浮点数输出时之管用数字只数,并返更新前的价。
     
注意:float型实数最多供7位有效数字,double型褛最多提供15各项中数字,long。。。提供19各中数字
   C.操作子:为了简化操作,提供了相同密密麻麻操作子,操作子实际上是目的

      

        dec         |      数值数据采用十进制表示               |   
i/o

      

        hex         |      数值数据采取十六进制表示             |   
i/o

      

        oct         |      数值数据采纳八进制表示               |   
i/o

      

        setbase(int)| 
设置数据易基数为n(n为0,8,10,16),其中0表示缺省基数  |  i/o

      

        ws          |   提取空白符                              |    
i

      

        ends        |   插入空白符                              |    
o

      

        flush       |  刷新和流动相互关联的缓冲区                   |    
o

      

        resetiosflags(long)  |     清除参数所指定的标志位       |   
i/o

      

        setiosflags(long)    |     设置参数所指定的标志位       |   
i/o

      

        setfill(int)         |     设置填充字符                 |    
o

      

        setsprecision(int)   |     设置浮点数输出的灵光数字只数 |    
o

      

        setw(int)            |     设置输出数据项之域宽         |    
o

      

  1. 字符串流:例170始发
          c++提供了少于个像样:头文件#include”strstrea.h”
            
    1.ostrstream:其是起ostream派生来的,将不同类型转换为字符串,并存放到数组中.
                
    ostrstream::ostrstream();//缺省构造函数,它因而来树立存储所插入的数据的数组对象;
                 ostrstream::ostrstream(char *s,int n,int
    mode=ios::out);//此构造函数中S是字符指针或字符数组,N是用来指定那一个数组最多会存的字符个数.mode参数为闹流式的方,缺省为out模式,还而采用ate和app格局.
               ostrstream类还提供了如下的成员函数:
                 int ostrstream::pcount();//再次来到流中都插入的字符个数;
                 char *ostrstream::str(); //再次回到标志字符串的数组的指针值;
            
    2.istrstream:其是从istream派生来的,将文本项转换为变量所急需之里边格式.     
                 istrstream::istrstream(char
    *s);//构造函数中S是一个字符指针或字符数组,使用该串来开始化要成立的流对象
                 istrstream::istrstream(char *s,int
    n);//此构造函数是应用串中前N个字符来协会串对象
    22.杀处理
          try{   }
          throw 变量
          catch(情势参数变量){   }
    //其中形数参数变量只好是一个,且项目无法如函数传递形参这样举办机动转换,必须完全批配
      
    注意:1.当找不交带领配项时,就用伪认批配项abort()一停程序               
             2.那么些处理的数据类型是国有基类,抛掷异常的数据类型是派生类
            
    3.很处理的数据类型是负为国有基类的指针,抛掷十分的数据类型是凭于派生类的指针
               
    catch(基类)总能捕获throw(派生类对象),所以catch(基类)块总是在catch(派生类)块的前边,以防止catch(派生类)永远不克捕获非凡