C++學習第四課

1.this指針
   當前的對象，在類的內部訪問成員使用，pubic，protected，private；
   只能在非靜態成員函數內部使用；
 
   2. static 在C++中
    static在類的內部修飾變量，對象是共享使用，在類內聲明，在類外定義；
     類型  類名：：變量名 = 數值；
     
   在類內聲明的時候前面加static，在類外初始化的時候不需要加static
   類外不初始化static變量不能使用
   
   三種訪問形式：
   1.通過類名：int Student::m_total = 0;
   2. 通過對象：
       Student stu("小明", 15, 92.5f); 
       stu.m_total = 20; 
   3.通過堆上對象指針來訪問：
    Student *pstu = new Student("xiaoming", 16, 89);
    pstu->m_total = 30;




 3. static 靜態成員函數
   沒有this指針，只能訪問靜態成員；
   
   
   4. const
   cost成員函數可以訪問類內的所有元素，但是不能修改，const函數稱爲常成員函數；
   void setage(int age)與void setage(int age) const     是兩個不同的函數
   
   const對象：常對象，只能訪問類的const成員
   
   
   
   5. 友元函數與友元類
    友元可以訪問當前類的所有成員：public，protected，private；
    
   友員函數不能直接訪問類的內部成員，必須要藉助對象
   void show(Student *pstu)
  {
  cout<< pstu->m_name<<","<<pstu->m_age<<","<<pstu->m_score<<endl;
  }
  
  類內聲明，類外定義；
  關鍵字friend
  
  1）獨立函數聲明爲友員函數
  2）其他類的成員函數聲明爲友員函數
  友員的單向關係，不能傳遞：
  B是A的友員，C是B的友員，C是A的友員？   這個是不成立的 
  
   3）友元類
   類A是類B的友員，那麼A的所有函數都是B的友員
    友員類是單向的，不是雙向的；
    
    
    
    6.string
    string  s1；  只定義不初始化，編譯器自動給空；
    string  s2=“suqian”；定義的時候初始化；  只有六個元素，不包含\0，如果在c中是7個
    
    string s3 = s2； s2的內容賦值給s3；
    
    string s4 (5, 's'); 在s4中填5個s；
  
    7. length
   求字符串的長度
    string s = "suqian";
    int lenth = s.length();
    
    8.cin 字符串的輸入輸出；
    string s1;
    cin>>s1;
    nanjing  jiangning
    cout<<s1<<endl;
    輸出只有nanjing，cin遇到空格自動結束；s1只有nanjing；
    
    9.string可以訪問下標
    
    10.string字符串的拼接；+，+=；
    string s1 = "abcd";
    string s2 = "123";
    string s3;
    s3 =s1+s2;
    cout<<s3<<endl;
    輸出：abcd123
    
    10.string插入；
    它的一種原型爲：
    string&  insert (size_t pos, const string& str);
    pos：要插入的位置；
    str：要插入的字符串；
    string s1,s2,s3;
s1 = "1234567890";
s2 = "abcdefgh";
s3 = "abc";
s1.insert(5, s3);  第5個位置，插入abc
cout<<s1<<endl;
s2.insert(3,"123"); 第3個位置，插入123
cout<<s2<<endl;

11.刪除erase（）
原型爲：string& erase (size_t pos = 0, size_t len = npos);

pos:起始的下標，
len：刪除的長度；
如果len不確定的話，把pos後面的全部刪除；

12.提取：substr（）
原型爲：
string substr (size_t pos = 0, size_t len = npos) const;
pos：提取的下標， len是長度；

13.字符串的查找find
查找出現的位置：
它其中的兩種原型爲：
    size_t find (const string& str, size_t pos = 0) const;
    size_t find (const char* str, size_t pos = 0) const;
    
    str：查找的字符串，
    pos：開始的下標
   
   出現問題正常：沒找到 
    string s1 = "one two  three four";
string s2 = "fince";


int index = s1.find(s2, 0);
int len  = s1.length();
if(index < s1.length())
        cout<<"Found at index : "<< index <<endl;
    else
        cout<<"Not found"<<endl;
        
    出現問題：index  = -1； 
    string s1 = "one two  three four";
string s2 = "fince";


int index = s1.find(s2, 0);
int len  = s1.length();
if(index < len)
        cout<<"Found at index : "<< index <<endl;
    else
        cout<<"Not found"<<endl;    
        
        
        
      13.繼承
      一個類從另外類中獲取變量和函數，稱爲繼承；
      
      父類，基類；
      子類，派生類；
      繼承的一般語法：
      class  派生類名：繼承方式  基類名｛
      派生類的成員；
      ｝；


繼承的方式：public，protect，private，不寫的話默認private


1.基類中的public可以在派生類中使用；
         基類中的protected也可以在派生類中使用；
         基類中private成員不能在派生類中使用；
   public>protected>private
        
 2.public形式繼承的：
  基類中的public成員還是public：
  ........protected成員還是protected；
  ........private成員不能在派生類中使用；
  
  3.protected繼承：
  基類中public成員在派生類中爲protected屬性；
  ......protected............protected.....;
  ......private在派生類中不能使用；
  
  4.private繼承；
  基類中的public成員在派生類中爲private屬性；
  ........protected............private.....;
  ........private成員在派生類中還是不能使用；   




訪問基類中的private成員必須藉助基類中public屬性的函數；
否則在派生類中無法訪問；






基類創建的對象：只能訪問基類的public成員變量，不能訪問protected，private屬性的變量；


在派生類創建的對象，也不能訪問基類的protected，private變量成員，只能public；
基類中的protected屬性成員，1.只能在派生類的內部函數訪問，2.基類中的函數也可以訪問；




5. using改變訪問權限
Using不能修改基類的private成員，在派生類中無法訪問基類的private；
可以把public改成派生類中的private，也可以將基類中protected改成public，或者是private；




6.繼承時的名字遮攔
 派生類的成員和基類中的成員重名，那麼就會遮攔從基類繼承過來的成員；
 派生類在使用該成員時，實際上是派生類新增的成員，不是從基類中繼承來的
 
 
 在基類和派生類中，不管是成員變量，還是成員函數，只要名字一樣就會造成遮蔽；
 
 
 7.派生類的構造函數
  構造函數不能被繼承，
  派生類的構造函數可以調用基類的構造函數類實現；
  Student::Student(char *name, int age,float score):People(name,age), m_score(score){}
  
  
  
  1.20
  
  1.名字的遮蔽
  基類的成員函數和派生類的成員函數不構成重載；
  基類成員和派生類成員的名字一樣會造成遮蔽；
  
  2.派生類的構造函數
  構造函數不能被繼承；
  在派生類的構造函數中可以調用基類的構造函數來實現
  
  3.構造函數的調用順序
   基類A，派生出B,B再派生出C；
   他們的構造函數調用順序：
   A -->  B--->C
   
   派生類構造函數中只能調用直接基類的構造函數，不能調用間接基類的構造函數；
   
   
   4.析構函數
   基類的析構函數不能被繼承；
   基類和派生類：A，B，C
   構造的時候順序：A，B，C
   析構的順序：C， B， A
   
   
   5. 多繼承類
   class C:public A, public B, public D{
   
   };
   多繼承下的構造函數，和單繼承一樣，都是調用基類的構造函數；
   
   6. 命名衝突
   當多繼承的時候，如果c分別從A和B繼承函數，如果是函數名有相同，編譯器會報錯，這個時候要加上：：來進行說明；
   
   7.虛繼承虛基類；
   表示共享它的基類：virtual
   
   8.虛繼承的時候，多繼承的狀態下，間接的基類最終由最終的派生類來確定初始化的值；
   
   最終的派生類D來初始化虛基類A，直接派生類B和C對A的構造函數的調用是無效的；
   
   
   
//直接基類B
class B: virtual public A{  //虛繼承
protected:
    int m_b;
};


//直接基類C
class C: virtual public A{  //虛繼承
protected:
    int m_c;
};


8.引用
相當於一個別名；
語法格式：type &name = data;
int  xiaoW;
int &xiaoG = xiaoW;
1) &不是地址預算法，是一個引用運算符
2）xiaoG,xiaoW變量的地址和值都是一樣；
3） 引用只能初始化，不能先聲明後賦值；相當於一個常量；
4）。在聲明一個引用的時候必須初始化；
5）.這個別名別人不能用，只能這個變量使用；改變變量的值，這個別名的值也會改變；


開始定義初始化的時候&表示引用運算符；
引用初始化後，&表示區地址運算符；


可以對對象和變量進行引用；
但是不能對類進行引用，因爲類沒有內存地址；