C++学习day4

news2024/11/17 2:03:53

作业：

1> 思维导图

 2> 整理代码

1. 拷贝赋值函数课上代码

//拷贝赋值函数课上代码
#include<iostream>
using namespace std;

//创建类
class Stu
{
private://私有的
    string name;
    int socer;
    int *age;//此处注意用到指针类型
public://共有的
    //无参构造函数（系统默认设置）
    Stu()
    {
        cout << "Stu:: 无参构造函数 " << endl;

    }
    //有参构造函数（自定义，自定义后需要将无参构造函数显性）
    Stu(string n,int s,int a):name(n),socer(s),age(new int (a))//初始化列表
    {
        cout << "Stu:: 有参构造函数" << endl;

    }
    //拷贝构造函数
    Stu(const Stu &other):name(other.name),socer(other.socer),age(new int(*other.age))//此处注意*other.age：因为定义是指针类型所以要去指针指向的内容进行赋值
    {
        cout << "Stu:: 拷贝构造函数" << endl;
    }
    //拷贝赋值函数
    Stu &operator=(const Stu &other) //此处不能用初始化列表因为是赋值操作
    {
        if(this != &other)//给自己赋值多此一举
        {
            name=other.name;
            socer=other.socer;
            age = new int (*other.age);//深拷贝赋值因为有指针防止段错误。。。
        }
        cout << "Stu:: 拷贝赋值函数" << endl;
        //注意返回值是自身引用
        return *this;
    }
    //析构函数
    ~Stu()//会自动调用
    {
        cout << "Stu:: 析构函数" << endl;
    }

};
int main()
{
    Stu s1;//无参构造函数
    Stu s2("王一博",100,23);//有参构造函数
    Stu s3(s2); //拷贝构造函数====》将s2拷贝给s3==》Stu s3=s2


    s1=s3;//拷贝赋值
    return 0;
}

 2.匿名对象（用来初始化有名对象）课上代码

void fun(Stu g)//形参接收实参的值==》Stu g=Stu("lisa",120,25)
{

}
int main()
{
    Stu s1;//无参构造函数
    Stu s2("王一博",100,23);//有参构造函数
    Stu s3(s2); //拷贝构造函数====》将s2拷贝给s3==》Stu s3=s2

    //用到匿名对象给有名对象初始化
    Stu s4=Stu("赵云",88,40);
    //给数组初始化
    Stu s[2]={Stu("哪吒",200,40),Stu("张飞",300,30)};//和c中初始化相似
    //匿名对象作为函数实参使用
    fun(Stu("lisa",120,25));


    s1=s3;//拷贝赋值
    return 0;
}

 3.全局函数作友元,课上代码

//友元上课代码（全局函数作友元）
#include <iostream>
using namespace std;
//封装 房间类
class Room
{
    friend void goodfriend(Room &r);//关键字：friend
private://私有的
    string bedroom;//卧室
public://共有的
    string sittingroom;//客厅
public:
    Room()
    {
        //在类内赋值
        bedroom="卧室";
        sittingroom="客厅";
    }
};
//全局函数作友元
void goodfriend(Room &r)
{
    cout << "好朋友正在参观" << r.sittingroom << endl;//共有权限访问成功毋庸置疑
    cout << "好朋友正在参观" << r.bedroom << endl;//报错原因：私有权限类外不可访问，需要用友元
}

int main()
{
   Room r;
   goodfriend(r);
   return 0;
}

4.成员函数作友元，课上代码

//成员函数作友元
#include <iostream>
using namespace std;
class Room;//需要声明一下，以免下面用到系统不知道报错
//封装好朋友类
class goodfriend
{
private:
    Room *r;//用到指针是因为指针的大小是固定的，而变量的大小不明，系统无法分配空间
public:
    goodfriend();//在类内声明
    void vist();//在类内声明
};

//封装 房间类
class Room
{/*
    friend void goodfriend(Room &r);//关键字：friend*/
    friend void goodfriend::vist();
private://私有的
    string bedroom;//卧室
public://共有的
    string sittingroom;//客厅
public:
    Room()
    {
        //在类内赋值
        bedroom="卧室";
        sittingroom="客厅";
    }
};
//类外实现
goodfriend::goodfriend()
{
    r=new Room;//申请空间
}
void goodfriend::vist()
{
    cout  << "好朋友正在参观" << r->sittingroom << endl;//共有权限访问成功毋庸置疑
    cout << "好朋友正在参观" << r->bedroom << endl;//报错原因：私有权限类外不可访问，需要用友元
    //指针需要用->
}





全局函数作友元
//void goodfriend(Room &r)
//{
//    cout << "好朋友正在参观" << r.sittingroom << endl;//共有权限访问成功毋庸置疑
//    cout << "好朋友正在参观" << r.bedroom << endl;//报错原因：私有权限类外不可访问，需要用友元
//}

int main()
{
   Room r;
   //goodfriend(r);
   goodfriend g;
   g.vist();
   return 0;
}

 5.课前热身

int const a; //......
int const *p; //......
int * const p; //
int const * const p; //
const int fun() {}  //该函数是返回一个常整型变量

 6.常成员函数&&非常成员函数

1.非常对象可以调用常成员函数，也可以调用非常成员函数，优先调用非常成员函数

2.常对象只能调用常成员函数，如果没有常成员函数，则报错

#include <iostream>
using namespace std;
class Stu
{
private:
    string name;//只对该成员变量在常成员函数中可以被修改mutable
    int id;
public:
    Stu(){}
    Stu(string name,int id):name(name),id(id)
    {}
    //常成员函数
    void display()const //==》Stu const * const this;表示指针的值和指向都不可改
    {
        //this ->name ="li si";报错原因：因为被const修饰不可以更改
        cout << name << " " << id <<endl;
    }
    //非常成员函数
    void display()//==>Stu * const this;和常成员重载
    {
        this -> name ="lisi";
        cout << name << " " << id << endl;
    }

};

int main()
{
    cout << "Hello World!" << endl;
    const Stu s1("zhangsan",1001);//常对象
    s1.display();//常对象只能调用常成员函数
    return 0;
}

 7.成员函数来实现运算符重载

//运算符重载
#include<iostream>
using namespace std;

//构造类
class Club
{
private://私有的
    int age;
    int hight;
public:
    //无参
    Club(){}
    Club(int a,int h):age(a),hight(h)
    {

    }
    //成员函数实现算数运算符重载 加法
    const Club operator+(const Club &R)const//const 1：结果 2：右操作数 3：左操作数
    {
        //内部运算
        Club temp;
        temp.age=age+R.age;
        temp.hight=hight+R.hight;

        return temp;
    }
    //成员函数实现算数运算符重载 减法
    const Club operator-(const Club &R)const//const 1：结果 2：右操作数 3：左操作数
    {
        //内部运算
        Club temp;
        temp.age=age-R.age;
        temp.hight=hight-R.hight;

        return temp;
    }
    //成员函数实现算数运算符重载 乘法
    const Club operator*(const Club &R)const//const 1：结果 2：右操作数 3：左操作数
    {
        //内部运算
        Club temp;
        temp.age=age*R.age;
        temp.hight=hight*R.hight;

        return temp;
    }
    //成员函数实现算数运算符重载 除法
    const Club operator/(const Club &R)const//const 1：结果 2：右操作数 3：左操作数
    {
        //内部运算
        Club temp;
        temp.age=age/R.age;
        temp.hight=hight/R.hight;

        return temp;
    }
    //成员函数实现算数运算符重载 取余
    const Club operator%(const Club &R)const//const 1：结果 2：右操作数 3：左操作数
    {
        //内部运算
        Club temp;
        temp.age=age%R.age;
        temp.hight=hight%R.hight;

        return temp;
    }
关系运算符//
    //成员函数实现关系运算符重载 >
    bool operator>(const Club &R)const
    {
        if(age>R.age && hight>R.hight)
        {
            return true;
        }
        else
            return false;
    }
    //成员函数实现关系运算符重载 <
    bool operator<(const Club &R)const
    {
        if(age<R.age && hight<R.hight)
        {
            return true;
        }
        else
            return false;
    }
    //成员函数实现关系运算符重载 >=
    bool operator>=(const Club &R)const
    {
        if(age>=R.age && hight>=R.hight)
        {
            return true;
        }
        else
            return false;
    }
    //成员函数实现关系运算符重载 <=
    bool operator<=(const Club &R)const
    {
        if(age<=R.age && hight<=R.hight)
        {
            return true;
        }
        else
            return false;
    }
    //成员函数实现关系运算符重载 ==
    bool operator==(const Club &R)const
    {
        if(age==R.age && hight==R.hight)
        {
            return true;
        }
        else
            return false;
    }
 
    //成员函数实现关系运算符重载 >
    bool operator!=(const Club &R)const
    {
        if(age!=R.age && hight!=R.hight)
        {
            return true;
        }
        else
            return false;
    }
    //赋值运算符
    //成员函数实现赋值运算符重载 +=
   Club &operator+=(const Club &R)
    {
        age += R.age;
        hight += R.hight;
        return *this;//返回自身
    }
   //成员函数实现赋值运算符重载 -=
   Club &operator-=(const Club &R)
    {
        age -= R.age;
        hight -= R.hight;
        return *this;//返回自身
    }
   //成员函数实现赋值运算符重载 =
   Club &operator=(const Club &R)
    {
        age = R.age;
        hight = R.hight;
        return *this;//返回自身
    }
   //成员函数实现赋值运算符重载 *=
   Club &operator*=(const Club &R)
    {
        age *= R.age;
        hight *= R.hight;
        return *this;//返回自身
    }
   //成员函数实现赋值运算符重载 /=
   Club &operator/=(const Club &R)
    {
        age /= R.age;
        hight /= R.hight;
        return *this;//返回自身
    }
   //成员函数实现赋值运算符重载 %=
   Club &operator%=(const Club &R)
    {
        age %= R.age;
        hight %= R.hight;
        return *this;//返回自身
    }



    void show()
    {
        cout << "age= " << age << " " << "hight= " << hight << endl;
    }
};
int main()
{
    Club c1(10,10);
    Club c2(10,10);


    Club c3=c1+c2;
    Club c4=c1-c2;
    Club c5=c1*c1;
    Club c6=c1/c2;
    Club c7=c1%c2;

    cout << "算数运算符" << endl;
    c3.show();
    c4.show();
    c5.show();
    c6.show();
    c7.show();

    cout << "关系运算符" << endl;

    if(c3!=c1)
    {
        if(c3>c1)
        {
            cout << "c3>c1 " << endl;
        }
        else if(c3<c1)
        {
            cout << "c3<c1 " << endl;
        }
        cout << "c3!=c1" << endl;

    }
    else if(c3 == c1)
    {

         if(c3>=c1)
        {
            cout << "c3>=c1" << endl;
        }
        else if(c3<=c1)
        {
            cout << "c3<=c1" << endl;
        }

        {
            cout << "c3==c1" << endl;

        }

    }

    cout << "赋值运算符" << endl;//赋值函数不要加类型否则属于初始化会报错
    c3+=c2;
    c4-=c2;
    c5*=c1;
    c6/=c2;
    c7%=c2;

    c3.show();
    c4.show();
    c5.show();
    c6.show();
    c7.show();


    return  0;
}

效果图:

 8.全局函数实现运算符重载

//运算符重载
#include<iostream>
using namespace std;

//构造类
class Club
{
    friend const Club operator+(const Club &L,const Club &R);
    friend const Club operator-(const Club &L,const Club &R);
    friend const Club operator*(const Club &L,const Club &R);
    friend const Club operator/(const Club &L,const Club &R);
    friend const Club operator%(const Club &L,const Club &R);
    friend bool operator>(const Club &L,const Club &R);
    friend bool operator<(const Club &L,const Club &R);
    friend bool operator<=(const Club &L,const Club &R);
    friend bool operator>=(const Club &L,const Club &R);
    friend bool operator==(const Club &L,const Club &R);
    friend bool operator!=(const Club &L,const Club &R);
    friend Club &operator+=( Club &L,const Club &R);
    friend Club &operator-=( Club &L,const Club &R);
   
    friend Club &operator*=( Club &L,const Club &R);
    friend Club &operator/=(Club &L,const Club &R);
    friend Club &operator%=( Club &L,const Club &R);
    
private://私有的
    int age;
    int hight;
public:
    //无参
    Club(){}
    Club(int a,int h):age(a),hight(h)
    {
        
    }
    
    void show()
    {
        cout << "age= " << age << " " << "hight= " << hight << endl;
    }
};
//成员函数实现算数运算符重载 加法
const Club operator+(const Club &L,const Club &R)//const 1：结果 2：右操作数 3：左操作数
{
    //内部运算
    Club temp;
    temp.age=L.age-R.age;
    temp.hight=L.hight-R.hight;

    return temp;
}
   
//成员函数实现算数运算符重载 减法
const Club operator-(const Club &L,const Club &R)//const 1：结果 2：右操作数 3：左操作数
{
    //内部运算
    Club temp;
    temp.age=L.age-R.age;
    temp.hight=L.hight-R.hight;

    return temp;
}

//成员函数实现算数运算符重载 乘法
const Club operator*(const Club &L,const Club &R)//const 1：结果 2：右操作数 3：左操作数
{
    //内部运算
    Club temp;
    temp.age=L.age*R.age;
    temp.hight=L.hight*R.hight;

    return temp;
}
//成员函数实现算数运算符重载 除法
const Club operator/(const Club &L,const Club &R)//const 1：结果 2：右操作数 3：左操作数
{
    //内部运算
    Club temp;
    temp.age=L.age/R.age;
    temp.hight=L.hight/R.hight;

    return temp;
}
//成员函数实现算数运算符重载 取余
const Club operator%(const Club &L,const Club &R)//const 1：结果 2：右操作数 3：左操作数
{
    //内部运算
    Club temp;
    temp.age=L.age%R.age;
    temp.hight=L.hight%R.hight;

    return temp;
}
关系运算符//
//成员函数实现关系运算符重载 >
bool operator>(const Club &L,const Club &R)
{
    if(L.age>R.age && L.hight>R.hight)
    {
        return true;
    }
    else
        return false;
}
//成员函数实现关系运算符重载 <
bool operator<(const Club &L,const Club &R)
{
    if(L.age>R.age && L.hight<R.hight)
    {
        return true;
    }
    else
        return false;
}
//成员函数实现关系运算符重载 >=
bool operator>=(const Club &L,const Club &R)
{
    if(L.age>=R.age && L.hight>R.hight)
    {
        return true;
    }
    else
        return false;
}
//成员函数实现关系运算符重载 <=
bool operator<=(const Club &L,const Club &R)
{
    if(L.age<=R.age && L.hight>R.hight)
    {
        return true;
    }
    else
        return false;
}
//成员函数实现关系运算符重载 ==
bool operator==(const Club &L,const Club &R)
{
    if(L.age==R.age && L.hight==R.hight)
    {
        return true;
    }
    else
        return false;
}

//成员函数实现关系运算符重载 !=
bool operator!=(const Club &L,const Club &R)
{
    if(L.age!=R.age && L.hight>R.hight)
    {
        return true;
    }
    else
        return false;
}
//赋值运算符
//成员函数实现赋值运算符重载 +=
Club &operator+=( Club &L,const Club &R)
{
    L.age += R.age;
    L.hight += R.hight;
    return L;//返回自身
}
//成员函数实现赋值运算符重载 -=
Club &operator-=( Club &L,const Club &R)
{
    L.age -= R.age;
    L.hight -= R.hight;
    return L;//返回自身
}

//成员函数实现赋值运算符重载 *=
Club &operator*=( Club &L,const Club &R)
{
    L.age *= R.age;
    L.hight *= R.hight;
    return L;//返回自身
}
//成员函数实现赋值运算符重载 /=
Club &operator/=( Club &L,const Club &R)
{
    L.age /= R.age;
    L.hight /= R.hight;
    return L;//返回自身
}
//成员函数实现赋值运算符重载 %=
Club &operator%=(Club &L,const Club &R)
{
    L.age /= R.age;
    L.hight /= R.hight;
    return L;//返回自身
}


int main()
{
    Club c1(10,10);
    Club c2(10,10);


    Club c3=c1+c2;
    Club c4=c1-c2;
    Club c5=c1*c1;
    Club c6=c1/c2;
    Club c7=c1%c2;

    cout << "算数运算符" << endl;
    c3.show();
    c4.show();
    c5.show();
    c6.show();
    c7.show();

    cout << "关系运算符" << endl;

    if(c3!=c1)
    {
        if(c3>c1)
        {
            cout << "c3>c1 " << endl;
        }
        else if(c3<c1)
        {
            cout << "c3<c1 " << endl;
        }
        cout << "c3!=c1" << endl;

    }
    else if(c3 == c1)
    {

         if(c3>=c1)
        {
            cout << "c3>=c1" << endl;
        }
        else if(c3<=c1)
        {
            cout << "c3<=c1" << endl;
        }

        {
            cout << "c3==c1" << endl;

        }

    }

    cout << "赋值运算符" << endl;//赋值函数不要加类型否则属于初始化会报错
    c3+=c2;
    c4-=c2;
    c5*=c1;
    c6/=c2;
    c7%=c2;

    c3.show();
    c4.show();
    c5.show();
    c6.show();
    c7.show();


    return  0;
}

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/1077856.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

爬取微博热榜并将其存储为csv文件

爬取微博热榜并将其存储为csv文件

&#x1f64c;秋名山码民的主页 &#x1f602;oi退役选手&#xff0c;Java、大数据、单片机、IoT均有所涉猎&#xff0c;热爱技术&#xff0c;技术无罪 &#x1f389;欢迎关注&#x1f50e;点赞&#x1f44d;收藏⭐️留言&#x1f4dd; 获取源码&#xff0c;添加WX 目录 前言1.…
阅读更多...
每日leetcode_193二叉搜索树的最近公共祖先

每日leetcode_193二叉搜索树的最近公共祖先

每日leetcode_193二叉搜索树的最近公共祖先 记录自己的成长&#xff0c;加油。 题目出处&#xff1a;LCR 193. 二叉搜索树的最近公共祖先 - 力扣&#xff08;LeetCode&#xff09; 题目 思路&#xff1a; 解题 class Solution {public TreeNode lowestCommonAncestor(TreeNod…
阅读更多...
孙帅Spring源码

孙帅Spring源码

【视频来源于&#xff1a;B站up主孙帅suns Spring源码视频】【微信号&#xff1a;suns45】
阅读更多...
【二维前缀和】

【二维前缀和】

目录 一、题目解析二、算法原理三、代码实现 一、题目解析 二、算法原理 三、代码实现 #include <iostream> using namespace std; #include<vector> int main() {int n0,m0,q0;cin>>n>>m>>q;vector<vector<int>> arr(n1,vector&l…
阅读更多...
Easysearch Chart 0.2.0都有哪些变化

Easysearch Chart 0.2.0都有哪些变化

Easysearch Chart 包更新了&#xff0c;让我们来看看都有哪些变化&#xff1a; Docker 镜像升级 Service 名称调整&#xff0c;支持 NodePort 模式部署 现在让我们用 NodePort 模式部署一下&#xff1a; # helm search repo infinilabs NAME CHART VERSION …
阅读更多...
移动应用-Android-开发指南

移动应用-Android-开发指南

Android-UI开发指南 Android Studio调试UI设计UI框架布局Layout文本框 android的活动Activity基本概念Activity的生命周期Activity栈创建Activity管理ActivityActivity间传递数据 FragmentAdapterRecyclerViewRecyclerView Adapter&#xff08;适配器&#xff09;事件setOnItem…
阅读更多...
C++ 与基本数据类型：整型、布尔型与字符型

C++ 与基本数据类型：整型、布尔型与字符型

文章目录 参考描述数据类型基本数据类型与复合数据类型静态数据类型 整形数据类型有符号整型数据类型无符号整型数据类型符号位 最少内存空间概念确定大小sizeof 运算符 进制C 中的不同进制数值表示cout 与进制转化影响范围二进制 后缀字面量整型字面量的默认数据类型主动权整型…
阅读更多...
【UE5 Cesium】17-Cesium for Unreal 建立飞行跟踪器（2）

【UE5 Cesium】17-Cesium for Unreal 建立飞行跟踪器（2）

目录 效果 步骤 一、飞机沿航线飞行 二、通过切换相机实现在不同角度观察飞机飞行 效果 步骤 一、飞机沿航线飞行 先去模型网站下载一个波音737飞机模型 然后将下载好的模型导入到UE项目中&#xff0c;导入时需要勾选“合并网格体”&#xff08;导入前最好在建模软件中将…
阅读更多...
阿里云上了新闻联播

阿里云上了新闻联播

我是卢松松&#xff0c;点点上面的头像&#xff0c;欢迎关注我哦&#xff01; 阿里新任的CEO吴泳铭上央视新闻联播了! 在昨天的新闻联播里&#xff0c;出席科技座谈会&#xff0c;有一个特别镜头&#xff0c;出现了阿里新任CEO吴泳铭的镜头。 这个信号意义明显&#xff0c;我…
阅读更多...
sentinel的启动与运行

sentinel的启动与运行

首先我们github下载sentinel Releases alibaba/Sentinel (github.com) 下载好了后输入命令让它运行即可&#xff0c;使用cmd窗口输入一下命令即可 java -Dserver.port8089 -jar sentinel-dashboard-1.8.6.jar 账号密码默认都是sentinel
阅读更多...
20哈希表-三数之和

20哈希表-三数之和

目录 LeetCode之路——15. 三数之和 分析&#xff1a; 官方题解&#xff1a; LeetCode之路——15. 三数之和 给你一个整数数组 nums &#xff0c;判断是否存在三元组 [nums[i], nums[j], nums[k]] 满足 i ! j、i ! k 且 j ! k &#xff0c;同时还满足 nums[i] nums[j] nu…
阅读更多...
黄金票据和白银票据

黄金票据和白银票据

文章目录 Kerberos使用背景kerberos认证流程黄金票据和白银票据 Kerberos使用背景 1、个人文件还是公司文件以及服务都存在于一台系统上&#xff0c;所有人都要去一台机器办公&#xff0c;效率非常低&#xff0c;为每个人分配了电脑以后就需要考虑安全问题 2、如何让服务器正确…
阅读更多...
一款好用的leetcode周赛插件：再也不用写代码的时候来回看描述了

一款好用的leetcode周赛插件：再也不用写代码的时候来回看描述了

今天发现了一个群友分享的一款leetcode插件&#xff0c;分享给大家。 对于熟悉leetcode的小伙伴应该会有一个困扰&#xff0c;那就是在leetcode打周赛的时候&#xff0c;题目描述和编辑区不是左右排版的&#xff0c;而是上下排版的&#xff0c;我们代码写着写着就需要移到最上…
阅读更多...
设计模式 - 行为型考点模式：责任链模式（概述 | 案例实现 | 优缺点 | 使用场景）

设计模式 - 行为型考点模式：责任链模式（概述 | 案例实现 | 优缺点 | 使用场景）

目录 一、行为型模式 1.1、责任链模式 1.1.1、概述 1.1.2、案例实现 1.1.3、优缺点 1.1.4、使用场景 一、行为型模式 1.1、责任链模式 1.1.1、概述 为了避免请求发送者和多个请求处理者耦合在一起&#xff0c;就将所有请求处理者通过前一个对象记住下一个对象的引用的方…
阅读更多...
飞行文本动画效果

飞行文本动画效果

效果展示 JavaScript 知识点 textContent.replace 方法运用anime.min.js 插件运用 实现整体页面布局 <section><p class"text">Lorem ipsum dolor sit amet consectetur, adipisicing elit. Impedit suscipitiure explicabo delectus laborum archite…
阅读更多...
AVS3：DMVR

AVS3：DMVR

AVS3中引入了解码端运动矢量修正&#xff08;DMVR,Decoder side Motion Vector Refinement&#xff09;技术&#xff0c;AVS3中的DMVR技术和G.266/VVC类似&#xff0c;它可以在解码端生成运动参数从而减少传输运动参数的码率开销。它的基本思想是将skip/direct模式生成的前后向…
阅读更多...
ArcGIS/GeoScene脚本：基于粒子群优化的支持向量机回归模型

ArcGIS/GeoScene脚本：基于粒子群优化的支持向量机回归模型

参数输入 1.样本数据必须包含需要回归的字段 2.回归字段是数值类型 3.影响因子是栅格数据&#xff0c;可添加多个 4.随机种子可以确保每次运行的训练集和测试集一致 5.训练集占比为0-1之间的小数 6.迭代次数&#xff1a;迭代次数越高精度越高&#xff0c;但是运行时间越长…
阅读更多...
MODBUS-RTU通信协议功能码+数据帧解读(博途PLC梯形图代码)

MODBUS-RTU通信协议功能码+数据帧解读(博途PLC梯形图代码)

MODBUS通信详细代码编写，请查看下面相关链接，这篇博客主要和大家介绍MODBUS协议的一些常用功能码和具体数据帧解析，以便大家更好的理解MODBUS通信和解决现场实际问题。 S7-1200PLC MODBUS-RTU通信 博途PLC 1200/1500PLC MODBUS-RTU通讯_博图modbus rtu通讯实例-CSDN博客1、…
阅读更多...
博弈论——动态博弈

博弈论——动态博弈

动态博弈 0 引言 前面一篇文章介绍了博弈过程中的三个分类&#xff1a;静态博弈、动态博弈、重复博弈。今天具体讲讲动态博弈的处理方法。 博弈论——博弈过程 1 概念 首先还是介绍一下动态博弈的概念&#xff0c;即博弈中各博弈方的选择和行动不仅有先后次序&#xff0c;而…
阅读更多...
USB协议层数据格式

USB协议层数据格式

USB协议 1. 硬件拓扑结构2. 协议层2.1 字节/位传输顺序2.2 SYNC域2.3 包格式2.3.1 PID域2.3.2 令牌包(Token)2.3.3 数据包2.3.4 握手包 2.4 传输细节2.4.1 传输(Transfer)和事务(Transaction)2.4.2 过程(stage)和阶段(phase)2.4.3 批量传输2.4.4 中断传输2.4.5 实时传输2.4.6 控…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023