Kill someone who wirting C++&Java!

杀了那个写C++和Java的人！

Wirte by 021. Leave a message if i messed up ! : )

封装&继承&多态

//
//  myMain.cpp
//  Assembly
//
//  Created by jiankang on 2020/11/22.
//


#include <stdio.h>
#include<string.h>
#include <stdlib.h>

struct person2
{
public:
    int age;
    char name;
    char* heapObject;
    
    
    void printThis()
    {
        printf("this当前指针=%p\n",&(this->name));
    }
    person2(int age,char name)
    {
        this->age = age;
        this->name = name;
        //heapObject = (char*)malloc(1024);
        printf("有参构造函数执行了，成员变量赋值初始化 \n");
    }
    person2()
    {
        printf("空参构造函数执行了 \n");
    }
    //析构函数 负责清理工作，Java的finalize
    ~person2()
    {
        printf("析构函数执行了，对象要销毁了 \n");
        //释放内存
        //free(heapObject);
    }
    virtual void print(){
        printf("person2父类多态方法被调用了 \n");
    }
     
};

//继承
class teacher :public person2
{
    private:
        int coachAge;
    
    virtual void print(){
        printf("teacher子类多态方法被调用了 \n");
    }
};

void myPrint(person2* p){
    p->print();
}


#include "myMain.hpp"

person2 p1; //全局变量，堆中分配，构造函数和析构函数(进程退出之前)都会执行;
int main(int argc, const char* argv[])
{
    
    //局部变量在堆栈中分配,构造函数和析构函数(方法退出之前)都会执行
    person2 p;
    printf("this会存储在ecx寄存器中,当前指针=%p\n",&p);
    p.printThis();

    int* ip = (int*)&p;
    printf("ip当前指针=%p\n",&ip);
    int* ip1 = ++ip;
    printf("ip当前指针=%p\n",&ip1);
    
    //堆中分配对象,利用空参构造创建一个对象
    person2* p3 = new person2();
    // new 汇编 ： _nh_malloc ~ 系统函数malloc ;  new = malloc + 构造函数;
    //释放堆中对象
    delete p3;
    
    //C中申请内存
    int* cp = (int*)malloc(sizeof(int)*10);
    person2* mallocP = (person2*)malloc(sizeof(person2)*10); //不会调用构造函数与析构函数;

    //释放
    free(cp);
    free(mallocP);
    //C++申请内存
    int* cp1 = new int[10];
    person2* cpp = new person2[10]; //会调用构造函数与析构函数;
    
    //释放
    delete[] cp1;
    //delete cpp; //只删除数组首元素；
    delete[] cpp; //删除堆中所有对象；
    
    /**
     * 引用类型-当前变量的别名 ; 变量地址的引用;    mov xRef , x[address]
     */
    int x = 10;
    printf("当前被引用类型指针=%p value=%d \n",&x,x);
    int& xRef = x;
    printf("xRef当前指针=%p value=%d \n",&xRef,xRef);
    xRef = 20;
    printf("xRef当前指针=%p value=%d \n",&xRef,xRef);
    
    int** ipp = (int**)1;
    int** ipRef = ipp;
    ipRef = (int**)2;
    printf("ipRef当前指针=%p value=%d \n",&ipRef,ipRef);
    
    // 指针与引用的差异
    int* xp = &x;
    xp++;  //int* xp - 减到一颗星的宽度，再自增 ，int为4 , 指针地址自增;
    printf("xp++当前指针=%p value=%d \n",&xp,xp);
    xRef++; // 引用运算，只运算被引用对象的值;  此时 x= 21;
    printf("xRef++当前指针=%p value=%d \n",&xRef,xRef);
    
    
    /**
     * 多态 virtual关键字
     * 同一方法，能体现父类与子类的相同方法的不同体现;
     * 间接调用; 动态调用地址; 多态应用
     * 直接调用; 地址是静态的，非多态应用
     *
     */
    myPrint(&p); //person2父类多态方法被调用了
    teacher* t = new teacher();
    myPrint(t); // teacher子类多态方法被调用了

    /**
     * 模板设计模式 template<class T> 对应java的泛型，编译器把不同地址编译在调用函数中.
     */
    
    /**
     * static就是私有全局变量;
     */
    
}