8. C++ 面向对象之特性一（封装）

面向对象主要包括三大类：封装，继承，多态

1.类和对象

c++认为，万物皆为对象，对象上有其属性和行为

人可以作为对象，属性有姓名、年龄、身高、体重...，行为有走、跑、跳、吃饭、唱歌...
车也可以作为对象，属性有轮胎、方向盘、车灯...,行为有载人、放音乐、放空调...
具有相同性质的==对象==，我们可以抽象称为==类==，人属于人类，车属于车类

对象是类的实例。

2.封装

1.封装的意义

1. 将属性和行为统一为一个整体，表现为生活中的事物

2. 将属性和行为加以权限控制

封装意义一：
将属性和行为统一为一个整体，表现为生活中的事物
语法： class 类名{ 访问权限： 属性 / 行为 };

示例1：设计一个圆类，求圆的周长

没学封装之前，用C语言实现：

#include<stdio.h>
double circleCaculate(double r)
{
    return 3.14*r*r;
}
int main(int argc, char const *argv[])
{
    double r = 1.2;
    double area = circleCaculate(r);
   return 0;
}

在这里面r相当于属性，circleCaculate()相当于行为，在C语言里属性和行为是分开的；

用封装实现

#include<iostream>
using namespace std;
class Circle
{
public:                 //protected  private  权限
    int r;              // 属性

    double circleCaculate()     // 行为
    {
        return 3.14*r*r;
    }
};
int main(int argc, char const *argv[])
{

    Circle c;           //  Circle是类  c是对象
    c.r = 1.2;
    area = c.circleCaculate();
    cout<<area<<endl;
    return 0;
}

类不占内存，但可以用sizeof计算出它的大小，对象才占内存。

示例2：设计一个学生类，属性有姓名和学号，可以给姓名和学号赋值，可以显示学生的姓名和学

//学生类
class Student {
    public:
        void setName(string name) {
            m_name = name;
        }
        void setID(int id) {
            m_id = id;
        }
        void showStudent() {
            cout << "name:" << m_name << " ID:" << m_id << endl;
        }
    public:
        string m_name;
        int m_id;
        };
int main() {
    Student stu;
    stu.setName("德玛西亚");
    stu.setID(250);
    stu.showStudent();
    system("pause");
    return 0;
}

封装意义二：
可以把属性和行为放在不同的权限下，加以控制

访问权限有三种：
1. public 公共权限
2. protected 保护权限
3. private 私有权限

//三种权限
//公共权限 public 类内可以访问 类外可以访问
//保护权限 protected 类内可以访问 类外不可以访问
//私有权限 private 类内可以访问 类外不可以访问
class Person
{
    //姓名 公共权限
    public:
        string m_Name;
    //汽车 保护权限
    protected:
        string m_Car;
    //银行卡密码 私有权限
    private:
        int m_Password;
    public:
    void func()
    {
        m_Name = "张三";
        m_Car = "拖拉机";
        m_Password = 123456;
    }
};
int main() {
    Person p;
    p.m_Name = "李四";
    //p.m_Car = "奔驰"; //保护权限类外访问不到
    //p.m_Password = 123; //私有权限类外访问不到
    system("pause");
    return 0;
}

//三种权限
//公共权限 public 类内可以访问 类外可以访问
//保护权限 protected 类内可以访问 类外不可以访问
//私有权限 private 类内可以访问 类外不可以访问

2.struct和class区别

在C++中 struct和class唯一的区别就在于 默认的访问权限不同
区别：
struct 默认权限为公共
class 默认权限为私有，如果想访问必须明确为public权限

class C1
{
    int m_A; //默认是私有权限
};
struct C2
{
    int m_A; //默认是公共权限
};
int main() {
    C1 c1;
    c1.m_A = 10; //错误，访问权限是私有
    C2 c2;
    c2.m_A = 10; //正确，访问权限是公共
    system("pause");
    return 0;
}

3.成员属性要设置为私有

优点1：将所有成员属性设置为私有，可以自己控制读写权限
优点2：对于写权限，我们可以检测数据的有效性

class Person {
    public:
        //姓名设置可读可写
        void setName(string name) {
            m_Name = name;
        }
        string getName()
        {
            return m_Name;
        }
        //获取年龄
        int getAge() {
            return m_Age;
        }
        //设置年龄
        void setAge(int age) {
            if (age < 0 || age > 150) {
                cout << "你个老妖精!" << endl;
                return;
            }
            m_Age = age;
        }
        //情人设置为只写
        void setLover(string lover) {
            m_Lover = lover;
        }
    private:
        string m_Name; //可读可写 姓名
        int m_Age; //只读 年龄
        string m_Lover; //只写 情人
};
int main() {
    Person p;
    //姓名设置
    p.setName("张三");
    cout << "姓名： " << p.getName() << endl;
    //年龄设置
    p.setAge(50);
    cout << "年龄： " << p.getAge() << endl;
    //情人设置
    p.setLover("苍井");
    //cout << "情人： " << p.m_Lover << endl; //只写属性，不可以读取
    system("pause");
    return 0;
}

4.类的声明和定义

可以类的声明，和类的定义分离，在.h文件中声明，在.cpp文件中定义

用客户端的代码来举例：

头文件：

#ifndef CLIENT_H
#define CLIENT_H
#include<iostream>
#include <sys/types.h>      
#include <sys/socket.h>
#include<netinet/in.h>
#include<unistd.h>
#include <arpa/inet.h>
#include<cstdio>
#include<cstring>
#include<cstdlib>
class Tcpclient
{
    private:
        int sockfd;
        //临时
        struct sockaddr_in server_addr;
    public:
        Tcpclient(const std::string& serverIp,short port);
        ~Tcpclient();
        bool ConnectToServer();
        int SendToServer(const std::string& data);
        int RecvFromServer(char* buffer,int buffersize);
    
};
#endif

client.cpp

#include<iostream>
#include"client.hpp"
using namespace std;

Tcpclient::Tcpclient(const std::string& serverIp,short port){    
    //创建socket
    sockfd=socket(AF_INET,SOCK_STREAM,0);//ipv4 tcp
    if(sockfd<0){
        cerr<<"Failed to create socket"<<endl;
        sockfd=-1;
        return;
    }
    //服务的地址：IP 端口号
    server_addr.sin_family=AF_INET;
    server_addr.sin_port=htons(port);
    server_addr.sin_addr.s_addr=inet_addr(serverIp.c_str());
}
Tcpclient::~Tcpclient(){
    close(sockfd);
}
bool Tcpclient::ConnectToServer(){
    if(connect(sockfd,(struct sockaddr *)&server_addr,sizeof(server_addr))<0){
        cerr<<"connect err"<<endl;
        return false;
    }
    cout<<"connect success!"<<endl;
    return true;
}
//
int Tcpclient::SendToServer(const std::string& data){
    return send(sockfd,data.c_str(),data.size(),0);
}
int Tcpclient::RecvFromServer(char* buffer,int buffersize){
    return recv(sockfd,buffer,buffersize,0);
}

main.cpp

#include"client.hpp"
using namespace std;
int main(int argc, char const *argv[])
{
    char buffer[1024]={0};
    Tcpclient tcp1("0.0.0.0",8082);
    tcp1.ConnectToServer();
    tcp1.SendToServer("hello");
    tcp1.RecvFromServer(buffer,sizeof(buffer));
    cout<<buffer<<endl;
    return 0;
}