c++基础学习课程

一，第一个C++代码

#include <iostream>
#include <cstdio>
//如果想要用到C库里的内容，需要包含C库的头文件，头文件的格式：头文件前面加上c，不需要写后缀.h
//#include 宏----后面紧跟的内容是库文件或者是用户自定义的头文件

搭建一个简单程序框架；

二，基础中的重点知识“ 类和对象 ”

1.类（class）
    描述现实世界中的事物，用C++进行编程的时候，通常是将现实世界中的事物用类来进行描述，类的关键字：class，描述一个人，特征：姓名、年龄、性别、肤色等等，行为：吃饭、睡觉、走路、跑步等等，类是一个泛指（抽象）的概念，不是特指某一个事物，简单的理解为没有实实在在存在于现实世界中（只是你脑海里一个概念）
用类描述事物的格式：
    class   类名（标识符名称）
    {
        //特征---变量
        //行为---函数
    }；

例如；人，有姓名，性别，年龄等特征,有睡觉，吃饭，跑步等行为

class People

{

public:

        char name;

        char sex;

        int age;

        void eat()

        {

        }

        void sleep()
        {

        }

        void run()

        {

        }

}

2.对象

         对象是类的实例化（特指实际的例子），是特指的概念，例如：人（泛指的概念）-----对人进行实例化------张三（特指的概念）
对象的实例化格式：
       （1） 在栈区实例化--------栈区实例化的对象，不需要用户手动的去释放内存，编译器会自动释放内存
格式：
    类名   对象名（标识符名称）；
例如：
    People  zhangsan;
    类似C里的------>int   a;

访问成员格式：
    对象名（标识符名称）. 成员；
例如：
    zhangsan.eat（）；//访问People里的eat方法

       

（2）在堆区实例化-------堆区实例化的对象，需要用户手动的去释放内存，如果不释放，很容易造成内存泄露
格式：
    类名   *  对象名（标识符名称）= new  类名；
例如：
    People * lisi  = new  People；

访问成员格式：
    对象名（标识符名称）-> 成员；
例如：
    lisi->sleep();

3.类的成员访问修饰符
    作用：为了保护类的成员，C++提供了三种类的成员访问修饰符
public（公共）、protected（受保护）、private（私有）

友元
    目的：给类的外部提供一个访问类的私有成员的接口
关键字：friend，用关键字来声明友元函数和友元类
（1）友元函数
    C++提供了友元函数就可以通过友元函数访问到类的私有成员，C++规定是友元函数声明在类里，就表示该函数是该类的友元，那么就可以通过友元函数访问类的私有成员.

友元函数的定义放置在类的外部;

void people()

{

}

声明格式（在类里声明）：
    friend 返回值类型  函数名（参数列表）；//友元函数的声明
定义（在类外定义）：如friend void people();

4.各类函数格式

People （） //无参构造函数
    {
        
    }

People （int a）//有参构造函数
    {
        
    }

总结：构造函数与普通函数的区别
不同点：
a、普通函数前有返回值类型，而构造函数前没有返回值
b、普通函数后面没有初始化列表，而构造函数后有初始化列表
c、普通函数调用的时候以显式调用的方式，而构造函数不仅可以显示的调用还可以隐式的调用
相同点：
d、都可以带参数或者是不带参数
e、都可以发生重载

~People （） //析构函数作用：释放空间
    {
        
    }

People（const People & obj）//拷贝构造函数
    {
        作用：把一个对象里的成员变量和它的值拷贝了一份儿给另外一个对象
    }

三、运算符重载
1、重载、重写、隐藏（覆盖）
（1）重载
    一般是发生在函数中，C++也支持运算符重载
解释：
    C++里的函数名相同、函数的参数个数、类型、顺序不同，可以发生重载（函数重载）
例如：
    void function（）
    {

    }
    void function（int）
    {

    }
    void function（char）
    {

    }
    void function（int , char）
    {

    }
    void function（char , int）
    {

    }
（2）重写
    就是将原来函数重新复制一份（函数的返回值、函数名、参数个数、类型、顺序都相同）
例如：
    void funiton()
    {

    }
    void funiton()
    {

    }
（3）隐藏（覆盖）
    就是将原来函数（变量）重新复制一份，就将原来的函数（变量）覆盖（隐藏），隐藏一般用的最多的是具有继承关系的两个类中

2、运算符重载
    C++里对基本的运算符重新赋予新的运算，例如，以前的加法（+）只能用于两个基本类型的数据进行相加，但是对于非基本类型的数据就不适用。C++对基本的运算符进行重载，重载之后就可以用于非基本类型的数据的运算。
    在类中运算符重载实际上是给类定义运算（类的对象能进行基本运算符的运算操作），强制修饰为函数的调用
算术运算符：+、-、*、/、%、++、--
位操作运算符：&、|、~、^(位异或)、>(右移)
逻辑运算符：!、&&、||
比较运算符：<、>=、>等等
赋值运算符：=、+=、-=、*=、/=、%=、&=、|=、^=、>=
其他运算符：[]、()、->、,、new、delete、new[]、delete[]、*指针运算符。

（1）普通成员函数的运算符重载
关键字：operator
声明格式：
    返回值类型（可以是基本的数据类型&自定义的数据类型） operator  被重载的运算符 （参数列表）；
定义格式：
    返回值类型（可以是基本的数据类型&自定义的数据类型） operator  被重载的运算符 （参数列表）
    {
        //函数体
    }

例如：
class Test
{
public:
    int a = 10;
    int b = 20;
    //实现两个对象中a相加并且b相加
    Test operator +(const Test& obj)
    {
        Test test;
        test.a = this->a - obj.a;
        test.b = this->b - obj.b;
        return test;
    }
};

int main()
{
    Test test1;
    Test test2;
    Test test3;
    test3 = test1 + test2;
    cout << "test3.a=" << test3.a << endl;
    cout << "test3.b=" << test3.b << endl;
    return 0;
}    

（2）友元函数的运算符重载
关键字：friend、operator
声明格式：
    friend  返回值类型（基本的数据类&自定义的类型） operator   被重载的运算符  （参数列表）；
定义：
     返回值类型（基本的数据类&自定义的类型） operator   被重载的运算符  （参数列表）
    {
        //函数体
    }
 

（3）一般函数的成员运算符重载
关键字：operator
声明格式：
    函数返回值类型（自定义的类型&基本的数据类型） operator 被重载的运算符 （参数列表）
    {
        //函数体
    }

四、继承与多态
1、继承
    一个类的对象共享了另一个类或其他多个类的成员变量和成员方法（子类还可以自己扩充自己的特征和行为），例如：儿子继承父亲（儿子具备父亲的特征和行为），该类和另一个类或其他类的关系，称之为“继承”，C++继承又分为单继承和多继承。
单继承：
    一个类的对象共享了另一个类的成员变量和成员方法
多继承：
    一个类的对象共享了其他多个类的成员变量和成员方法
单继承的格式：
    class  新的类名（子类）  ：  继承的权限   已经存在的类（父类）
    {
        //类体
    }；

//新的类我们称之为子类（派生类），已经存在的类我们称之为父类（基类）
//继承的权限：public、private、protected
例如：
class Father
{
public:
    int a = 50;
    void function()
    {
        cout << "这是父类的成员函数" << endl;
    }
};
class  Son : public Father //表示Son类继承自Father
{
public:
    void son_func()
    {
        cout << "a=" << a << endl;
    }
};
int main()
{
    Son zhangsan;
    zhangsan.son_func();
    zhangsan.function();
    return 0;
}
（1）父类和子类的构造和析构函数的调用时机
    构造时，先调用父类的构造函数，再调用子类的构造函数，析构时，先调用子类的析构函数，再调用父类的析构函数
（2）如果子类和父类有同样的特征或者是行为？
    如果子类和父类有相同的变量或者是函数，那么子类会自动屏蔽（隐藏）父类与子类相同的变量或者是函数，如果子类和父类没有相同的变量或者是函数，那么父类的变量和函数就会继承到子类

2、继承的权限
    C++提供了继承的权限：public、private、protected，目的是对继承加以限制
public继承：
（1）父类的public下的成员就全部继承到子类的public属性下
（2）父类的protected下的成员变量是继承到子类的protected属性下，父类的protected下的成员函数没有继承到子类
（3）父类的private下的成员是没有继承到子类的private属性下
protected继承：
（1）父类的public下的成员就全部继承到子类的protected属性下
（2）父类的protected属性下的成员全部继承到子类的protected属性下
（3）父类的private下的成员是没有继承到子类的private属性下
private继承：
（1）父类的public下的成员就全部继承到子类的private属性下
（2）父类的protected属性下的成员全部继承到子类的private属性下
（3）父类的private下的成员是没有继承到子类的private属性下
注：
    一般都是选择共有（public）继承。

感谢观看本期的c++基础心得，希望大家都好好学习，共同进步！