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）.这个别名别人不能用，只能这个变量使用；改变变量的值，这个别名的值也会改变；


开始定义初始化的时候&表示引用运算符；
引用初始化后，&表示区地址运算符；


可以对对象和变量进行引用；
但是不能对类进行引用，因为类没有内存地址；