C++编程基础——宏、函数、面向对象

函数

函数重载（Function Overload）

函数名相同，但形参类型列表不同（即形参的数量或类型不同）。

默认参数（Default Argument）

函数参数可以带默认值，简化函数调用。

默认参数必须全部放在形参列表的最右边，并且必须连续排列。

面向对象编程

OOP：Object Oriented Program，面向对象编程。

对象（Object）：任何一个具体的事物。

类（Class）：具有相同特征的一些对象的抽象，并不是具体存在的事物。

对象是类的实例（Instance），类是对象的抽象。

实例化：通过类定义对象。

在OOP中，类其实就是一个（复杂）数据类型，跟结构体几乎一样，通过类类型定义的变量或常量我们通常称之为对象。

类就是一种自定义数据类型，必须先声明，然后才能用它定义对象。

类中成员可以为成员变量（Menber Variables，或称属性）、成员函数（或称方法）等。

属性（Attribute）：用于描述同类对象的静态特征。比如一个人的体重、血型等。

方法（Method）：用于描述同类对象的动态行为。比如人可以讲话、学习等。

成员访问权限：

• private：私有的，只能在本类中访问。
• protected：保护的，只能在本类中和子类中访问。
• public：公有的，所有地方（本类中、子类中和类外）都可以访问。

类中成员的默认访问权限为private，而结构体中成员默认访问权限为public。

对象的所占内存空间大小是由所有非静态属性决定，计算方法和结构体完全一致。

静态属性和成员函数在内存中只有一份，所有对象共享，所以它们所占内存空间没有算在每个对象的头上。

面向对象编程的三大特性：

• 封装：

  1. 类就是将数据和对数据的操作整合在一起构成一个独立的整体，封装级别比普通函数更高。
  2. 将类中数据对外隐藏，让外界不能直接访问，如果确实需要访问，就提供一些接口（公有的办法）供外界调用实现间接访问。

每个非静态方法内部有一个隐含的指针常量，它的名字为this，它指向调用该方法的那个对象。

this 也是 C++ 关键字，表示当前对象的指针。

• 继承
• 多态

实例一：对于宏的使用（换行符’ \ '、do…while）

//宏的使用
#include <iostream>

void e()
{
    #define XYZ 10
    //换行符
    #define qq using namespace std;\
    cout << XYZ <<endl;\
    cout << 1+1 <<endl;

    #define show(x) do {printf("%s\n",(x));printf("end\n")} while(0)
}

int main()
{
    qq
    return 0;
}

实例二：函数重载、默认参数

#include <iostream>

int sum(int,int);
double sum(double,double);
double sum(double,double,double);

int main()
{
    using namespace std;
    cout << sum(12,3) << endl;
    cout << sum(1,2,3) << endl;
    return 0;
}

int sum(int a,int b)
{
    return a+b;
}
double sum(double a,double b)
{
    return a-b;
}
double sum(double a,double b,double c)
{
    return a+b+c;
}

实例三：类访问成员变量与成员函数

#include <iostream>
#include <cstring>
using namespace std;

//定义（声明）一个类，类名为 Person 
class Person{
    //类体（Class Body）
public:     //公有的
    //成员变量或属性
    int sno;
//private:    //私有的
    char name[21];  

    // 成员函数或方法
    void speak()
    {
        cout << "I can speak !" << endl;
    }

    //方法重载
    void speak(int x)
    {
        ;
    }

    int study(int = 8)
    {
        cout << "I can study !" << endl;
        return 0;
    }

};

int main(){
    // 通过 Person 类定义对象 p1,p2,p3
    Person p1,p2;
    // 访问对象的属性
    p1.sno = 1001;
    strcpy(p1.name,"琛翀");
    cout << sizeof(p1) << endl;
    cout << sizeof(Person) << endl;

    // 访问对象的方法，即调用对象的方法
    p1.speak();
    p1.speak(1);
    p1.study();

    //通过对象的指针访问其成员
    Person* q1 = &p1;
    q1 -> sno = 1005;
    cout << "q1->sno=" << q1->sno <<endl;
    strcpy(q1 -> name, "小王");
    q1 -> speak();


    //通过对象引用访问其成员
    Person& m1 = p1;
    cout << "m1.name=" << m1.name <<endl;
    return 0;
}

实例四：默认定义私有成员变量、公有成员函数，如有需要可设访问函数；

#include <iostream>
#include <cstring>
using namespace std;

class Student{
private:
    int sno;
    char name[21];
    string addr;
public:
    void setSno(int sno1){
        //this->sno = sno;//参数列表为sno
        sno = sno1;
    }
    void setName(char* name1){
        strcpy(name,name1);
    }
    void setAddr(string addr1){
        addr = addr1;
    }

    int getSno(void){
        //return this->sno;
        return sno;
    }

    const char* getName(void){
        return name;
    }
    const string getAddr(void){
        return addr;
    }
    const void show(void){
        cout << sno << " " << name << " " << addr << endl;
    }
    
};
int  main(){
    //栈区对象
    Student s1;
    s1.setSno(1005);
    char name[21];
    string addr;
    cin >> name >>addr;
    
    s1.setName(name);
    s1.setAddr(addr);
    s1.show();

    /*
    //堆区对象
    Student* s2 = new Student;
    s2->setSno(1006);
    s2->show();
    delete s2;
    */
    return 0;
}