c++的各种名词大集合以及注意事项

这里给出的比较杂乱没有先后顺序，仅仅是提供复习的一个小博客

1. 重载函数

函数名同，但是参数形式不同，含参个数不同，参数顺序不同

注意的是：
1.返回值类型不同不构成重载函数
2.二义性

#include<bits/stdc++.h>

using namespace std;

void point (int x)
{
    cout<<"姐姐不会吃醋吧"<<endl;
}

void point(int x,int y)
{
    cout<<"我只会心疼哥哥"<<endl;
}

int main()
{
    point(1);
    point(1,2);
}
//返回值种类要相同，函数名相同，含参：个数，种类，顺序不同
//#include<bits/stdc++.h>
//
//using namespace std;
//
//int main()
//{
//    int sum(int x, int y);
//    float sum(int x, int y);
//
//}（不对）返回值种类要相同

运算符重载
+

person operator+(person &p1,person &p2)
{
    person temp;
    temp.m_a = p1.m_a + p2.m_a;
    temp.m_b = p1.m_b + p2.m_b;
    return temp;
}

<<

ostream & operator<<(ostream &cout,person &p)
{
    cout<<p.m_a<<p.m_b;
    return cout;
}

2.纯虚函数

格式： virtual 函数名 = 0
注意事项：
1.最后面的0，不表示返回值，只是一种形式表示告诉编译器这个是纯虚函数
2.纯虚函数只有函数名但是没函数功能，所以不能调用
3.纯虚函数的作用，实现多态性

3.抽象类

#include<bits/stdc++.h>

using namespace std;

class Base
{
public:
    //只要有一个纯虚函数，这个类称为抽象类
    //无法实例化对象
    virtual void func() = 0;


};

class son : public Base
{
public:
    virtual void func(){cout<<"这是什么东西"<<endl;};

};
//无法实例化对象
void test01()
{
    //Base k;
    son d;
    d.son::func();
}

int main()
{
    test01();
}

4.多态实例

//多态实例 1

//煮水 冲泡 倒入杯中 加入辅料

//提供制作饮品基类，提供子类制作咖啡和茶叶
#include<bits/stdc++.h>

using namespace std;

class Abstractdrink
{
public:

    //煮水
    virtual void boil() = 0;

    virtual void chong() = 0;

    virtual void incup() = 0;

    virtual void zuoliao() = 0;

    void makeduink()
    {
        boil();
        chong();
        incup();
        zuoliao();
    }

};

class coffee:public Abstractdrink
{
public:
    virtual void boil()
    {
        cout<<"煮农夫山泉"<<endl;
    }
    virtual void chong()
    {
        cout<<"冲咖啡"<<endl;
    }
    virtual void incup()
    {
        cout<<"倒入杯中"<<endl;
    }
    virtual void zuoliao()
    {
        cout<<"导入佐料"<<endl;
    }

};

class tea:public Abstractdrink
{
public:
    virtual void boil()
    {
        cout<<"煮百岁山"<<endl;
    }
    virtual void chong()
    {
        cout<<"冲茶叶"<<endl;
    }
    virtual void incup()
    {
        cout<<"倒入我们滴戈楞机"<<endl;
    }
    virtual void zuoliao()
    {
        cout<<"挤上柠檬"<<endl;
    }

};

void dowork(Abstractdrink *abs)
{
    abs->makeduink();//直接用一个函数套上所有的虚函数就成
    delete abs;
}

void test01()
{
    dowork(new coffee);

    cout<<"----------------"<<endl;

    dowork(new tea);
}

int main()
{
    test01();
}

5.虚析构，纯虚析构

//可以解决父类指针释放子类对象
//都需要有具体函数实现

6.四大区

1.代码区：存放函数体的二进制代码，由操作系统管理的
2.全区区：存放全局变量和静态变量（在里面外面都一样）以及常量
3.栈区：由编译器自动分配释放，存放函数的参数值，局部变量等
4.堆区：由程序员分配和释放，若程序员不是放，程序结束时回收
c++中——堆区主要用 new在堆区开辟内存

7.构造函数的分类和调用

两种分类方式：
1.有参构造函数，无参构造函数
2.普通构造函数，拷贝构造函数

三种调用方法：
1.括号法
2.显示法
3.隐式转换法

#include<bits/stdc++.h>

using namespace std;

class person
{
public:

    person()
    {
        cout<<"无参构造"<<endl;
    }
    person(int a)
    {
         age = a;
        cout<<"有参构造"<<endl;
    }
    person(const person &p)
    {
        age = p.age;
        cout<<"拷贝构造函数"<<endl;
    }
    int age;
    ~person()
    {
        cout<<"析构"<<endl;
    }
};

void test01()
{
    //1.括号法
    person p;//默认构造函数就是无参构造函数，不要加小括号编译器认为是函数得声明
    person p1(10);
    person p2(p1);
    cout<<p1.age<<" "<<p2.age<<endl;
    //2.显示法
    person p1;
    person p2 = person(10);
    person p3 = person(p2);

    //3.隐式法
    person p4 = 10;
    person p2 = p4;

}

int main()
{
    test01();
}
//拷贝构造函数const person &p；！！！！！

并且只要是写出一个类编译器至少给这个类添加三个函数，构造，析构，拷贝

8.深拷贝和浅拷贝

浅拷贝：简单得赋值拷贝操作
深拷贝：在堆区重新申请空间，进行拷贝操作

#include<bits/stdc++.h>

using namespace std;

class person
{
public:

    person()
    {
        cout<<"无参构造的调用"<<endl;
    }
    person(int age,int height)
    {
        cout<<"有参构造的调用"<<endl;

        m_age = age;
        m_height = new int(height);
    }

    ~person()
    {
        cout<<"析构函数的调用"<<endl;

        if(m_height != NULL)
        {
            delete m_height;
            m_height  = NULL;

        }
    }

    person(const person & p)
    {
        cout<<"拷贝构造函数"<<endl;

        m_age = p.m_age;

        //m_height = p.m_height;
        //深拷贝
        m_height = new int(*p.m_height);

    }
    int m_age;
    int *m_height;
};

void test01()
{
    person p1(18,160);
    cout<<p1.m_age<<endl;
    person p2(p1);
    cout<<p2.m_age<<*p2.m_height<<endl;

}

int main()
{
    test01();
}

9.类对象作为类成员

#include<bits/stdc++.h>
using namespace std;

  class phone
  {
  public:
      phone(string name):p_name(name)
      {
          puts("phone构造函数调用");
     }
     string p_name;
 };

class person
 {
 public:
     //pname p_name = b;//隐氏转换法
    person(string a,string b):name(a),pname(b)
    { 
            puts("person构造函数调用");
    }
 string name;
 phone pname;
 };

 void test()
 {
     person p("Steve","Iphone 11 Pro");
     cout << p.name << " have a " << p.pname.p_name << endl;
 }

 int main()
 {
     test();
     return 0;
 }

10.函数模板，类模板

//函数模板：
template<class T> 
T func(int a,int b)
{
     return a*b;
}

#include<bits/stdc++.h>

using namespace std;

template<class T>
class num
{
public:

    int m_a;
    int m_b;
    num(int a,int b)
    {
        m_a = a ;
        m_b = b ;
        cout<<m_a<<" "<<m_b<<endl;
    }
    T max(T a,T b)
    {
        if(a > b)return a;
        else return b;
    }
};

int main()
{
    int a,b;
    cin>>a>>b;
    num<int>q(a,b);
    cout<<q.max(a,b);
}

11.引用

引用：给变量起别名，指针常量

#include<bits/stdc++.h>
using namespace std;
//引用的本质就是给变量起别名
int main()
{
    int a = 10;

    int &b = a;
    b= 20;
    cout << a << endl;
    return 0;
}

//引用做函数参数
#include<bits/stdc++.h>

using namespace std;
//值传递形参不会修饰实参
void myswap(int a, int b)
{
    int temp = a;
    a = b;
    b = temp;
    cout << b<< " "<< a;
}就是这个里面的a,b会发生变化

int main()
{
    int a = 10;
    int b = 20;
    myswap(a , b);
    cout << b<< " "<< a;
}a,b不变换

//下面是地址传递，因为改变的是最原始的地址所以直接变换
#include<bits/stdc++.h>

using namespace std;

void myswap(int *a, int *b)
{
    int temp = *a;
    *a = *b;
    *b = temp;

}

int main()
{
    int a = 10;
    int b = 20;
    myswap(&a , &b);
    cout << b<< " "<< a;
}

用引用来调用函数形参实参都可以改变
using namespace std;

void myswap(int &a, int &b)
{
    int temp = a;
    a = b;
    b = temp;
cout << b<< " "<< a;
}

int main()
{
    int a = 10;
    int b = 20;
    myswap(a , b);
    cout << b<< " "<< a;
}

12.文件

#include<bits/stdc++.h>
#include<fstream>

using namespace std;

void test01()
{
    ifstream ifs;

    ifs.open("test.txt",ios::in);

    if(!ifs.is_open())
    {
        cout<<"无法读出";
        return;
    }

    //读文件第一种
//    char buf[1024] = {0};
//
//    while(ifs >> buf )
//    {
//        cout << buf <<endl;
//    }

    char buf[1024] = {0};
    while(ifs.getline(buf,sizeof(buf)))
    {
        cout << buf << endl;
    }

    ifs.close();
}

int main()
{
    test01();
}

文件操作：
ofstream 写文件
ifstream 写文件
fstream 读写文件

13.继承

#include<bits/stdc++.h>

using namespace std;

class page
{
public:
    void po()
    {
        cout<<"公共部分"<<endl;

    }

};

class java:public page
{
public:
    void content()
    {
        cout<<"java 的 内容"<<endl;
    }

};

class cpp:public page
{
public:
    void content()
    {
        cout<<"c++ 的 内容"<<endl;
    }

};

void test01()
{
    java ja;
    ja.content();
    ja.po();
    cpp c;
    c.content();
    c.po();
}

int main()
{
    test01();
}

减少重复的代码
class 子类 ：继承方式 父类
（公共继承方式）
子类就是派生类
父类就是基类

保护继承
父类中所有非静态成员属性都会被子类继承下去
父类中私有成员属性让编译器隐藏了，因此是访问不到，但是确实是继承下去 了

多继承类语法：
允许一个儿子认多个爹就是多次继承

class 子类 ： 继承方式 父类1，继承方式 父类2

多继承可能会发生父类中同名成员的出现，需要加作用域区分
（开发中不太用）

//继承中子类父类构造函数以及函数的如何输入输出
#include<bits/stdc++.h>

using namespace std;

class base
{
public:
    int m_a;
    base()
    {
        m_a = 100;
    }
    void func(int a)
    {
        cout<<"base"<<endl;
    }
};

class son : public base
{
public:
    int m_a;
    son()
    {
        m_a = 200;
    }
    void func(int a)
    {
        cout<<"son"<<endl;
    }
};

//void test01()
//{
//    son s;
//    cout<<"son "<<s.m_a<<endl;
//    cout<<"base"<<s.base::m_a<<endl;
//}

void test02()
{
    son s;
    s.func(100);
    s.base::func(100);
}

int main()
{
    test02();
}

菱形继承：

#include<bits/stdc++.h>

using namespace std;

class Animal
{
public:
    int m_age;
    Animal()
    {
        m_age = 100;
    }
};

class sheep:virtual public Animal
{

};

class tuo :virtual public Animal{};

class sheeptuo : public sheep,public tuo
{

};
//利用虚继承可以解决菱形继承的问题
void test01()
{
    sheeptuo st;
    cout<<st.sheep::m_age;

}

int mian()
{
    test01();
}
//因为两个子类都是虚的所以虚基类是Animal
//相当于就是变成一个类两个参数然后都变成一个东西

.杂碎

1.C++是既支持面向对象的程序设计又支持面向过程的程序设计的混合型语言
2.string 中不会输入空格
3.考虑下面的函数原型声明：
void testDefaulParam(int a,int b=7,char z=’’);
下面函数调用中，不合法的是（ C ）。
A. testDefaulParam(5); B. testDefaulParam(5,8);
C. testDefaulParam(5,’#’); D. testDefaulParam(0,0,’’);

不可以跳着，可以不写

4.在一个函数中，要求通过函数来实现一种不太复杂的功能，并且要求加快执行速度，选用（ A /B ）。
A. 内联函数 B. 重载函数
5.只有类中的成员函数或类的友元函数才能存取类中的私有成员
6.在类中，如果不做特别说明，所有成员的访问权限均为私有的（可以尝试一下不写public：不让调用的）
7.X array[3];时，调用了（ 3 ）次构造函数。

#include<bits/stdc++.h>

using namespace std;

class X
{
public:

    X()
    {
        cout<<"1"<<endl;
    }
    ~X()
    {
        cout<<"2"<<endl;
    }
};

int main()
{
    X t[3];
}

8.一个类只能定义一个析构函数，但可以定义多个构造函数（就是析构不能重载）
9.构造函数可以指定返回类型，而析构函数不能指定任何返回类型，即使是void类型也不可以
10.当const在函数名前面的时候修饰的是函数返回值，在函数名后面表示是常成员函数，该函数不能修改对象内的任何成员，只能发生读操作，不能发生写操作。
11.设置虚基类的目的是:消除二义性
12.

#include<bits/stdc++.h>

using namespace std;

class A
{
public:
    int a,b  ;
    A()
    {
        a = 2;
        b = 0;
    }
    void cao()
    {
        cout<<b;
    }
};

class B :public A//继承的话是两个点，而::表示作用域
{
public:
    B()
    {
        a = 3;
        cout<<a;
    }
    void cao()
    {
        b = 6;
    }
};

void test()
{
    A p;
    B k;
    //构造函数调用可不需要A p；cout<< p.A();   
    p.cao();
    //函数里面直接有输出不用输出函数！！（本人老是犯下的错误，看不懂可以跳过不是很重要）
}

int main()
{
    test();
}

13.类与类之间的友元关系可以继承（错）你爸爸的好基友不一定跟你击剑
14.成员函数是在类中定义的函数，而非成员函数就是普通函数，就是不是在类中定义的函数，其中非成员函数比较典型的是友元函数。

成员函数是类定义的一部分，通过特定的对象来调用。成员函数可以隐式访问调用对象的成员，而无须使用成员操作符。友元函数不是类的组成部分，因此被称为直接函数调用。友元函数不能隐式访问类成员，而必须将成员操作符用于作为参数传递的对象。
15.

16.// 编译错误：
static成员函数不能声明为virtual
virtual static void fun() { }

static 是不属于任何类对象或类实例，加上virtual是没有意义的
也因为静态成员函数没有this指针，然而virtual是有一个vptr指针的

17.基类中说明了虚函数后，派生类中与其对应的函数可不必说明为虚函数

18.类与类之间的友元关系可以继承（错误）不是成员函数

19.一个类的友元类中的成员函数都是这个类的友元函数

20.如果表达式++ik中的“++”和“”都是重载的友元运算符，若采用运算符函数调用格式，则表达式还可以表示为operator*(operator++(i),k)

21.类和对象的关系可表述为：类是对象的 抽象 ，而对象则是类的 实例 。
22.静态成员函数没有隐含的 this指针 ，所以，在C++程序中，静态成员函数主要用来访问静态数据成员，而不访问非静态成员。
23.
24.从实现的角度来讲，多态性可以划分为两类：静态多态性 和 动态多态性 。

25.如果一个类包含一个或多个纯虚函数，则该类称为 抽象类 。

26.若要把void fun()定义为类A的友元函数，则应在类A的定义中加入语句 friend void fun(A &a) 。

27.后置自增运算符“++”重载为类的成员函数（设类名为A）的形式为： A operator ++(int) 。
28.
29.析构函数和构造函数一样可以有形参（×）

30.

31.列出C++中两种用户自定义的数据类型： 类 、 结构体 。

32.运算符重载要求保持其原来的操作数个数、 结合性，优先级 、 和语法结构。

33.后置自增运算符“++”重载为类的成员函数（设类名为A）的形式为 A operater ++（int） 。

英语单词
public
private
protected
virtual friend void fun （A &a） 通过关键字
Temple 可以声明模板，通过关键字 class 指定函数模板的类型参数，有几个类型参数就有几个类型关键字。