C++第二节（1）:public和private、初始化列表、函数重载

public和private、初始化列表、函数重载

1、初始化列表：

     1.1 在构造函数函数头，对类的成员变量进行初始化

     1.2 ：成员变量（赋给成员变量的值）{}       赋给成员变量的值：形参或常数

2、重载函数：

     2.1函数名一样，参数列表不同（参数类型或参数个数不同）

     2.2 仅仅返回值不同是不可以的

A、public和private

#include <iostream>    //public和private
using namespace std;
class Student
{
private:
    int num;
public:
    char *name;
    Student();
    void setValue(int a, char *b);
    int getNum();
    char * getName();
    void print();
};
Student::Student()
{
    num = 000;
    name = "小强";
}
void Student::setValue(int a, char *b)
{
    num = a;
    name = b;
}
int Student::getNum()
{
    return num;
}
char * Student::getName()
{
    return name;
}
void Student::print()
{
    cout << name << endl;
    cout << num << endl;
}
int main()
{
    Student a;
    //a.name ="小明";  //公有成员变量，可以使用这种形式访问。
    //a.num = 123; //私有成员变量,只能通过公有成员函数才可以访问
    a.setValue(123456, "小红");
    a.print();
    cout << a.getNum() << endl;
    cout << a.getName() << endl;
    return 0;
}

B、默认、非默认、初始化列表

Thing.h

#ifndef __C__No727Class__Thing__
#define __C__No727Class__Thing__

#include <iostream>
using namespace std;
class Thing
{
public:
    //Thing();  默认构造函数，不带默认值，不能传参
    Thing(int a = 10, int b = 20, int c = 30);  //带默认值的默认构造函数，可以传参
    //Thing (int m, int n, int p);  //非默认构造函数，自定义的构造函数，传3个参数
    ~Thing();
    void printThing();
private:
    int x;
    int y;
    int z;
};
#endif /* defined(__C__No727Class__Thing__) */

Thing.cpp

#include "Thing.h"
//Thing::Thing()  对无参数的默认构造函数进行实现，初始化
//{
//    x = 10;
//    y = 20;
//    z = 30;
//}
//Thing::Thing(int a, int b, int c)  //对带默认值的默认构造函数进行实现
//{
//    x = a;
//    y = b;
//    z = c;
//}    //与下面使用初始化列表的语句等价
Thing::Thing(int a, int b, int c):x(a), y(b), z(c) {};
void Thing::printThing()
{
    cout << "x = " << x << "y = " << y << "z = " << z << endl;
}
Thing::~Thing()
{
    cout << "~~~" << endl;
}

main.cpp

#include "Thing.h"
int main(int argc, const char * argv[])
{
    Thing t;
    t.printThing();
    Thing s(1);
    s.printThing();
    Thing r(1, 2);
    r.printThing();
    Thing v(1, 2, 3);
    v.printThing();
    
    Thing *y = new Thing(5, 5, 5);  //类类型指针y，指向new的堆空间，堆空间里面是一个对象
    (*y).printThing();  //访问方式（*y).和y ->

    delete y;    //手工回收内存，把new的堆空间收回，即析构堆空间的对象，此时调用析构函数
    return 0;
}

C、函数重载

Overload.h

#ifndef __C__No727Class__Overload__
#define __C__No727Class__Overload__

#include <iostream>
using namespace std;
class Overload
{
private:
    int x;
    int y;
    int z;
public:
    Overload();  //无参数的默认构造函数
    Overload(int a, int b, int c);  //自定义函数，下面两个函数是对该函数的重载
    Overload(int a, int b);
    Overload(int a);
    void print();
};
#endif /* defined(__C__No727Class__Overload__) */

Overload.cpp

#include "Overload.h"
Overload::Overload()
{
    x = 75;
    y = 99;
    z = 66;
}
Overload::Overload(int a, int b, int c)
{
    x = a;
    y = b;
    z = c;
}
Overload::Overload(int a, int b)
{
    x = a;
    y = b;
}
Overload::Overload(int a)
{
    x = a;
}
void Overload::print()
{
    cout << "x = "<< x << "  y = " << y << "  z = " << z <<endl;
}

main.cpp

<pre name="code" class="cpp">#include "Overload.h"
int main()
{
    Overload t;      //默认值
    t.print();
    Overload s(1);   //只传递第一个值，其他值自动置为0
    s.print();
    Overload r(1, 2);
    r.print();
    Overload v(1, 2, 3);
    v.print();
    Overload a;
    a = t;           //对象的赋值
    a.print();
    a = v;
    a.print();
    return 0;
}