C++中的重载 类 构造函数 析构函数 拷贝构造函数 浅拷贝

/*
void fun (int a){}
void fun(int a){}c语言中是非法的
c++中函数重载
1 允许定义 名称相同的函数
2 特征标不同 参数数目不同 参数类型不同 参数顺序不同
void fun(int a)
   1 void fun(int a, int b)
   2 void fun(float b)
   3 void fun(int a, double b)
     void fun(double x, int y)
返回值是否能作为函数重载的依据？ 不能
函数重载遇上了函数的默认参数
int func(int a, int b, int c = 10)
int func(int a, intt b)   产生 二义性
*/

#include <iostream>
using namespace std;

void fun(int a, double b)
{
    cout << "执行了void fun(int a, double b)" << endl;
}

void fun(int a)
{
    cout << "执行了void fun(int a)" << endl;
}

void fun(int a, int b)
{
    cout << "执行了void fun(int a, int b)" << endl;
}

void fun(double a, int b)
{
    cout << "执行了void fun(double a, int b)" << endl;
}

/*void func(int a, int b, int c = 10);
{
    cout << "默认参数" << endl;
}

void func(int a, int b)
{
    cout << "无默认参数" << endl;
}*/
int main()
{
    int x = 1;
    double y = 3.14;
    int z = 2;
     
    fun(x,y);
    fun(x);
    fun(x,z);
    fun(y,x);

 //   func(x,z);
 //   func(x,z);
    return 0;
}
 

/*
面向过程：（怎么去解）以什么正在发生为主要目标
面向对象：（建立一个模型）（万物皆对象）（c++带类的c）（属性＋方法）
           以什么正在受影响为主要目标

面向过程的缺点：不容易扩展 不容易维护 不可以复用－－程序员加班
面向对象的有点：降低程序的耦合度（模块与模块之间信息或者参数的依赖程度牵一发而动全身）
                还可以保护数据，免遭不当的访问

类的封装
定义：把客观事物抽象成一个类，并且类可以把自己的数据和方法只让可信的类或者对象操作
怎么封装？1 c++把属性（成员变量）和方法（成员函数）
          2 对属性和方法进行访问控制 private public (protected)
        private:只有类的内部才可以访问 如果没有访问权限 默认为private
        public:类的内部，外部都可以访问
*/

#include <iostream>
using namespace std;

class Cuboid
{
private:
    int l;
    int w;
    int h;

public:
    void set(int m_l, int m_w, int m_h)
    {
        l = m_l;
    w = m_w;
    h = m_h;
    cout << "set successfully" << endl;
    }
    int get_V();//如果需要在类外定义成员函数 首先在类的内部需要有声明
   /* {
        return l * w * h;
    }*/
};

//返回值 类的名称::函数名
int Cuboid::get_V()
{
    return l * w * h;
}
int main()
{
    Cuboid cl;
    cl.set(3,4,5);
    cout << "体积是：" << cl.get_V() << endl;

    return 0;
}

#include <iostream>

using namespace std;

class Student
{
private:
    char *name;
    int old;
public:
    void set(char *m_name, int m_old)
    {
       // name = m_name;
        name = (char *)malloc(sizeof(char) *100);
        name = m_name;
        old = m_old;
    }

    void get_V()
    {
        cout << "姓名：" << name << " 年龄：" << old << endl;
    }
};
int main()
{
    Student cl;
    cl.set("liming",22);
    cl.get_V();

    return 0;
}
 

/*
构造函数：
1.形式？怎么写？
  c++中可以定义 与类名相同的特殊成员函数 并且没有返回值
  class Student
  {
      ....
  public:
      Student(){  }
  }
2.什么时候用构造函数？
  他会在每次创建类的新对象时候执行
3.有什么用？为什么要学习？
  主要用来在创建对象时候初始化对象的
4.怎么调用？
大部分一般情况下 自动调用 特殊情况会需要手动调用
默认无参构造函数：在类中没有定义构造函数时 编译器自动提供一默认  函数体是空的
默认

赋值（拷贝）构造函数：
   初始化 和 赋值    int a = 1;
                     int b = 10;  a = b;
    Test t1(10);//初始化
    Test t2(20);
    t1 = t2;//对象的赋值
    形式：
        Test(const Test& obj){a = m_a;}
    什么时候会调用？
    1 一个对象需要通过另一个对象来进行初始化 Test t1 = t2
    2 一个对象以值传递的方式传入函数体 void fun(Test t1)
    3 一个对象值传递的方式从函数返回 Test func(){...return t }
析构函数
1  ~Student(){...}（析构函数没有参数）
2   一般在对象销毁的时候被调用
3   清理对象
4   自动调用
*/
#include <iostream>
using namespace std;
class Test
{
private:
    int a;
    int b;
    int c;
    int d;
public:
    Test(int m_a)//构造函数
    {
        a = m_a;
    cout << "test construct!" << a << endl;
    }

    Test(int m_a, int m_b)
    {
        cout << "test(int a, int b).." << endl;
    }

    Test(int m_a, int m_b, int m_c, int m_d = 20)
    {
        a = m_a;
    b = m_b;
    c = m_c;
    d = m_d;

    cout << "four parameter.."  << endl;
    cout <<"d: " << d << endl;
    }

    ~Test(){cout << "test destruct!" << endl;}
    Test(const Test& obj)
    {
        a = obj.a + 100;
    cout << "copy construct!" << endl;
    }
    void display()
    {
        cout << "a: " << a << endl;
    }
};

/*Test::Test(int m_a)
{
    a = m_a;
    cout << "test comnstruct!" << a << endl;
}*/

void func(Test t)
{
    cout << "func" << endl;
}
int main()
{
    cout << "----------" << endl;
    Test t1(10);//创建对象
    cout << "----------" << endl;
    Test t2 = t1;
    t2.display();
    cout << "^^^^^^^^^^^" << endl;
    func(t1);
    t1.display();

    return 0;
}
 

/*
初始化列表在哪些情况下使用：
   1.对象成员
   2.？
      
      
      ① 构造函数的顺序 与 析构函数的顺序是相反的
      ② 对对象成员的初始化的顺序取决于这些对象在类中的创建顺序
         和初始化列表成员的顺序无关
     
     
student 浅拷贝
*/

#include <iostream>
using namespace std;

class Student
{
private:
    int id;
    char *name;
public:
    Student(int m_id, char *m_name)
    {
        id = m_id;
    name = (char *)malloc(sizeof(char)*100);
    strcpy(name,m_name);
    cout << "copy construct!" << endl;
    }
    ~Student()
    {
        id = 0;
    if(name != NULL)
    {
        free(name);
        name = NULL;
    }
    cout << "Student destruct" << endl;
    }

    void display()
    {
        cout << "id: " << id << " name: " << name << endl;
    }

    Student(const Student &obj)
    {
        id = obj.id;
        name = (char *)malloc(sizeof(char) *100);
    strcpy(name,obj.name);
    cout << "copy construct" << endl;
    }
};

int main()
{
    Student stu1(717,"zwd");
    stu1.display();
    cout << "-----------" << endl;
    Student stu2 = stu1;
    cout << "-----------" << endl;
    stu2.display();
    cout << "-----------" << endl;

    return 0;
}

思考：

1.浅拷贝与深拷贝在代码上的区别是否可以通过有没有对对象进行分配空间来判定？

2.一般来说，private私有成员变量不可在类外与子类中被调用，那可以在拷贝构造函数中被调用吗?（obj.id,obj.name????）