C++

目录

第一天

C++和C区别

cin的使用问题

字符串

引用

引用与指针的区别

 函数

结构体

数组和指针的引用

 

const

构造函数

析构函数

运算符重载

构造函数的调用顺序

菱形继承

多态

抽象类

count char * str = "Hello world!"; 

模板函数

---

 

第一天

C++和C区别

• C++面向对象（对象是类的实例，对象具有状态和行为），C面向过程
• C++ 几乎是 C 的超集，只有少量功能 C++ 不支持。
• C++一般针对大型项目，C一般做比较小的项目

cin的使用问题

• cin输入类型不匹配的情况：

#include

using namespace std;

void main()

{ int i = 0;

while(i<4)

{ int nNumb;

cin >> nNumb; //如果再输入的时候输入字符串类型例如“Hello”，则下次进入循环时遇到cin是不会阻塞 ++i;

}

return;

 

在cin >> 之前加上两句：cin.clear();cin.sync();即可清空输入缓存中的数据。这类似于C语言中在c = getchar();之前加上fflush(stdin); 

•  cin输入越界的问题

#include

using namespace std;

void main() { int i = 0;

while(i<4) {

char sName[8];

cin >> sName; //如果在输入的时候超过7个字符（因为字符串输入的时候，会自动在结尾处补零），//就会在析构cin的时候造成越界问题，引发程序崩溃。

++i;

}

return; 

 解决办法：　　使用cin.getline(sName,20);

cin的使用用法：见转载地址：https://www.cnblogs.com/laohan1221/p/6235880.html 

  int x=100;
  cout<字符串

https://www.runoob.com/cplusplus/cpp-strings.html

引用

int &y = x;                //建立变量X的引用，（给X取别名为y）。

引用与指针的区别

1、指针是一个实体，需要分配内存空间。引用只是变量的别名，不需要分配内存空间。

2、引用在定义的时候必须进行初始化，并且不能够改变。指针在定义的时候不一定要初始化，并且指向的空间可变。（注：不能有引用的值不能为NULL）

3、有多级指针，但是没有多级引用，只能有一级引用。

4、指针和引用的自增运算结果不一样。（指针是指向下一个空间，引用时引用的变量值加1）

5、sizeof 引用得到的是所指向的变量（对象）的大小，而sizeof 指针得到的是指针本身的大小。

6、引用访问一个变量是直接访问，而指针访问一个变量是间接访问。

 

 函数

内联函数：在函数名前面加  inline  关键字

• 非常短的函数适合于内联(无循环)
• 函数体会插入到发生函数调用的地方

 int inline fun(const int &a,const int &b) 
{
    return a+b;
}

重载函数 ：两个以上的函数，取相同的函数名，但是形参的个数或者类型不同，编绎器根据实参和形参的类型及个数的最佳匹配，自动确定调用哪一个函数，这就是函数的重载。

递归函数： 递归函数即自调用函数，在函数体内部直接或间接地自己调用自己。

参数默认的函数

• 调用函数时可以不指定全部参数
• 可以为不指定的参数提供默认值

         int  add(int  x = 5,int  y = 6,int  z = 3);

          main( )

          {       

                        add( );          //所有这三个参数都采用默认值                

                        add( 1,5);     //第三个参数采用默认值                

                        add(1,2,3);   //不使用默认值          

          }

 //注意：参数默认的函数 的参数从右往左必须是连续的含有默认值的参数。中间不能空有无默认值的参数。

         int add(int x,int y=10,int z,int a=10,int b=10)  比如左边的定义错误的！！

结构体

不同类型的结构体的集合。

struct student 
{
  private:
       string name ;
       int age ;
       double score ;
  public:
  void setname(string name)

  {   
       this->name = name ;
  } 

数组和指针的引用

 

int main()
{
  Student stu[3] ;
  stu[0].setname("solitary");
  stu[0].setage(23);
  stu[0].setscore(89.5);
  stu[0].print();

  Student (*parray)[3] = &stu;
  parray[0] -> print();

  Student (&yarray)[3] = stu;
  yarray[0].print();
  
  Student *ps = stu;
  Student *&yp = ps;
  yp->print();
}

const

• const指针可以指向非const变量 
• 非const变量不可以指向const变量
•  同理，非const变量不能引用const 变量 

#include
using namespace std;
class Student
{
    private:
      string name;
      int age;
    public:
      Student(string n="uname",int age =10)
      {
          name=n;
        this->age=age;
      }
      void setstudent(string n="uname",int age =0)
      {
          name = n;
        this->age=age;
      }
      void  print()const
      {
          cout<<"student :name="<       }
};
int main()
{
    const Student s1("lisi",12) ;  //对于有const修饰的对象时，只能调用其对象中有const修饰的方法 如上文中的 print()方法。
    s1.print();                              //没有const修饰的对象也可以调用该对象中有 const修饰的方法
}
 

构造函数

• 每个类都有一个无参的构造函数
• 若自定义了构造函数，则默认的无参构造函数就被屏蔽。
• 声明函数和实现函数时不能同时为参数设初值。 

Person ( string n,int a);                                          //类内声明构造函数

Person::Person ( string n="aaa",int a=21):name(n),age(a)    //类外实现初始化构造器  
{
    cout<<"Person create"< } 

class Person
{
    private:
      string name;
      int age;
      A a;
      Birthday bir;
      
    public:
      Person(string name,int age,int month,int day):name(name),age(age),bir(month,day),a(day) {

}    //先构造 a 然后再构造bir ，它是根据类中成员的顺序构造的。

析构函数

• 当对象结束时调用析构函数。 

• 析构函数没有参数。

Person (Person &p)

{

      *this = p;    //浅拷贝

} 

Person (Person &p)

{

       page = new int(*p.page);    //为了避免指针指向同一内存空间，使用深拷贝

}

运算符重载

      void operator += (double r)  
      {
          yuan = yuan +(int) r ;
        jiao =( r - (int) r ) * 10 + jiao ;
      }

      RMB &operator ++ ()         //左自增
      {
          jiao ++;
        if(jiao == 10)
        {
            yuan++;
            jiao=0;
        }
        return *this ;
      }
      RMB operator ++(int )   //右自增
      {
          RMB t = *this ;
        jiao++ ;
        if(jiao == 10)
        {
            yuan ++ ;
            jiao = 0 ;

        }
        return t ;
      }
 

构造函数的调用顺序

 先加载父类的构造函数，在加载子类中组合类的构造函数，最后加载子类的构造函数。

菱形继承

子类继承时加上"virtual"关键字，以解决多个父类继承的方法冲突。转载链接地址：http://c.biancheng.net/view/2280.html

多态

把在父类中和子类同名的方法之前加上virtual关键字，来可以通过指针或引用来调用子类的同名函数。

//在父类father中的fix()方法前加virtual 

class Father{    public :    virtual void fix(){}   };

class Son {  public : void fix(){}  };

Father fa ;

fa.fix();

Son son;

Father *fa = &son;

fa -> fix();    //调用的是子类son的fix方法

• 父类中的  protect 成员或函数，只能在子类的成员函数中调用(注意：只能是子类的函数成员中，不能再其它类中通过子类对象加 . 调用)，不能在其他函数中调用，就算父类自己的对象也调用不了。可以通过在子类或者父类中创建public方法，在创建的 public 方法中调用 protected修饰的方法。

 class Father
{
public:    void fix()    {        fixtv();    }     //

protected:    virtual void fixtv()    {        cout<<"father fix"< class Son:public Father
{
    protected:    void fixtv()    {        cout<<"son fix"< int main()
{
    Son son;
    Father *fa =&son;
    fa->fix();   //此处 写成 fa->fixtv()；会报错，因为Father中的成员函数 fixtv() 时protected类型
}

输出结果： son fix

抽象类

• 函数只要有纯虚函数的类是抽象类。
• 抽象类本身不能有自己的对象。
• 抽象类中的纯虚函数类必须要求继承他的子类实现。

virtual void print() = 0; //纯虚函数

count char * str = "Hello world!"; 

模板函数

template 

T my_add(T x,S y)

{
     

    T z = x + y ;

    return z;

}

int main()

{
     

    cout<

    return 0;

}