QML Quick实现一个十字路口红绿灯

已于 2024-08-17 08:53:55 修改
阅读量323 收藏 4
点赞数 4
文章标签： c++ c语言 qt
于 2024-08-17 08:29:10 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_55054495/article/details/141275209
版权

页面的布局

  1. 第一层 绿色Rectangle作为打底，布满窗口
  2. 第二层 两条灰色Rectangle布局成灰色十字型 anchors.leftMarginanchors.horizontalCenter用这两个进行中心布局都可以
  3. 第三层 分流线（矩形画）和斑马线（图片）和十字路口（矩形）
  4. 第四层 车（图片）
  5. 第五层 灯 （图片）

红绿灯逻辑(Connections)

十字路口如果只考虑直行，那么只需要封装一个红绿灯就可以，考虑横竖红绿灯角度不一致，图片不一样那就写成两个组件，唯一不同的就是图片的路径不一致

接收后端红绿灯变化的信号，一旦后端信号灯变化就改变红绿灯的展示，onCurrentLightStateChanged

这边灯用了一个图片，外加三个矩形化成的圆形进行覆盖

import QtQuick 2.12

Image {
    id: lightLeftRight
    source: "qrc:/cars/light"
    sourceSize.height: 100
    Rectangle {
        id: yellowLight
        width: 17
        height: 17
        radius: 50
        color: "#808080"
        anchors.horizontalCenter: parent.horizontalCenter
        anchors.verticalCenter: parent.verticalCenter
    }
    Rectangle {
        id: redLight
        width: 17
        height: 17
        radius: 50
        color: "#808080"
        anchors.horizontalCenter: parent.horizontalCenter
        y: 20
    }
    Rectangle {
        id: greenLight
        width: 17
        height: 17
        radius: 50
        color: "#808080"
        anchors.horizontalCenter: parent.horizontalCenter
        y: 62
        visible: false
    }

    Connections {
        target: trafficLightController // 假设trafficLightController是C++对象，已在QML上下文中设置
        onCurrentLightStateChanged: {

            if (newState === "Red") {
                redLight.visible = false;
                yellowLight.visible = true;
                greenLight.visible = true;
            } else if (newState === "Yellow") {
                redLight.visible = true;
                yellowLight.visible = false;
                greenLight.visible = true;
            } else {
                redLight.visible = true;
                yellowLight.visible = true;
                greenLight.visible = false;
            }

        }
    }



}

汽车运动的逻辑（Timer）

  1. 设置两个Timer，一个控制循环走，一个控制遇到信号灯处理
  2. 第一个Timer interval: 16 //每16毫秒检查一次位置repeat: true // 重复触发running: true // 开始时即运行

onTriggered触发

  • 没到底按正常走
  • 到底了重新设置x或y
  1. 第二个
  • 红灯停 moveTimer.running = false;（moveTimer是第一个Timer的名称）
  • 绿灯 moveTimer2.running = true; 启动 speed3 = fasterSpeed; 恢复正常速度
  • 快到斑马线的某段距离减速 speed3 = slowerSpeed;
  • 其他时候正常速度

 Image {
        id: downcar
        source: "qrc:/cars/downcar"
        sourceSize.height: 100
        anchors.left: loadCenter.left
        y: -downcar.height
        // 定时器组件
        Timer {
            id: moveTimer2
            interval: 16 // 约60fps
            running: true // 默认开始运行
            repeat: true
            onTriggered: {
                if (downcar.y < window.height) {
                    downcar.y += speed3;
                } else {
                    downcar.y = -downcar.height;
                }
            }
        }
        // 定时器组件
        Timer {
           id: positionCheckTimer2
           interval: 16 // 每50毫秒检查一次位置
           repeat: true // 重复触发
           running: true // 开始时即运行

           onTriggered: {
               if(downcar.y > positionCheckHeight-positionCheckLengthRange  && downcar.y< positionCheckHeight &&
                             trafficLightController1.currentLightState === "Red"){
                    moveTimer2.running = false;

                   } else if(trafficLightController1.currentLightState === "Green") {
                   moveTimer2.running = true;
                   speed3 = fasterSpeed;

                   } else if(downcar.y > positionCheckHeight-positionCheckLengthRange  && downcar.y< positionCheckHeight &&
                             (trafficLightController1.currentLightState === "Yellow" ||
                              trafficLightController1.currentLightState === "Red")) {
                   speed3 = slowerSpeed;

                   } else {
                       speed3 = fasterSpeed;
                   }
           }
       }

    }

后端逻辑代码

逻辑梳理

  1. Timer计时器 初始化时就设置好时间，当Timer一完成就改变信号灯
  2. 当信号灯改变，重新设置Timer计时器，并发出灯已经改变的信号
  3. 灯的属性值发生改变，发出currentLightStateChanged信号
  4. 前端通过onCurrentLightStateChanged获取信号 再根据newState判断信号灯
  5. 车的话就直接获取当前的信号灯trafficLightController1.currentLightState
Connections {
        target: trafficLightController1
        onCurrentLightStateChanged: {// 业务代码}
        }

两部分代码

TrafficLightController .h

#ifndef TRAFFICLIGHTCONTROLLER_H
#define TRAFFICLIGHTCONTROLLER_H

#include <QObject>
#include <QTimer>

class TrafficLightController : public QObject
{
    Q_OBJECT  // 宏

    Q_PROPERTY(QString currentLightState READ currentLightState NOTIFY currentLightStateChanged)

public:
    explicit TrafficLightController(QObject *parent = nullptr);

    QString currentLightState() const;  //  返回当前的红绿灯状态

signals:
    void currentLightStateChanged(QString newState); //  当前红绿灯信号改变

private slots:
    void changeLight(); //  改变红绿灯信号

private:
    enum LightState { Green, Yellow, Red };  // 枚举类型设置灯的信号
    int durations[3] = {7000, 3000, 7000}; // 持续时间：绿灯5秒，黄灯2秒，红灯5秒 水平方向信号灯
//  int durations[3] = {10000, 4000, 3000}; // 持续时间：红灯7秒，绿灯4秒,黄灯1秒，垂直方向信号灯
    LightState currentState;  // 当前的红绿灯状态
    QTimer timer;  // 控制红绿灯时间 
    QString lightStateToString(LightState state) const; // 返回红绿灯使用String类型返回
};

#endif // TRAFFICLIGHTCONTROLLER_H

TrafficLightController.cpp 

#include "TrafficLightController.h"

TrafficLightController::TrafficLightController(QObject *parent)
    : QObject(parent), currentState(Green)   // 初始化信号灯为绿灯
{
    connect(&timer, &QTimer::timeout, this, &TrafficLightController::changeLight); // Timer到时间发出信号改变信号灯
    timer.start(durations[currentState]);

}

QString TrafficLightController::currentLightState() const
{
    return lightStateToString(currentState);
}

void TrafficLightController::changeLight()
{
    static const int nextStateIndices[] = {1, 2, 0}; // 下一个状态索引
    int nextStateIndex = nextStateIndices[static_cast<int>(currentState)];
    currentState = static_cast<LightState>(nextStateIndex);

    timer.setInterval(durations[currentState]);
    emit currentLightStateChanged(lightStateToString(currentState));
}

QString TrafficLightController::lightStateToString(LightState state) const
{
    switch (state) {
    case Green:
        return "Green";
    case Yellow:
        return "Yellow";
    case Red:
        return "Red";
    default:
        return "Unknown";
    }
}

解释一下

Q_PROPERTY(QString currentLightState READ currentLightState NOTIFY currentLightStateChanged)

完整代码

代码目录

App.qml 

import QtQuick 2.12
import QtQuick.Window 2.12
import QtQuick.Controls 2.5
import QtQuick.Layouts 1.3
ApplicationWindow {
    id: window
    visible: true
    width: 1200
    height: 800
    title: qsTr("模拟十字路口车流")

    /**

// 十字路口 模拟车辆在十字路口 运动 图像的动画 运行轨迹 红绿灯显示 画一个矩形 设置不同
// 颜色 定时器（C++）变化 影响车的流动
    // 界面 十字路口
    // 红绿灯
    // 运动 红灯绿灯 走直线 定时器（C++）控制变化

      */

// 背景图片 绿地
    property real grassWidth: 50
    property real treeWidth: 66
    Rectangle {
        color: "#2a4d00"
        width: parent.width
        height: parent.height
    }



// 上下方向的道路
    Rectangle {
        id: upDownLoad
        color:  "grey";
        height: parent.height
        width: 200
//        anchors.left: parent.left
//        anchors.leftMargin: (parent.width-200)/2
        anchors.horizontalCenter: parent.horizontalCenter
        Rectangle {
            color:  "lightyellow";
            height: parent.height
            width: 10
            anchors.left: parent.left
            anchors.centerIn: parent;
        }
    }


// 左右方向的道路
    Rectangle {
        id: leftRightLoad
        color:  "grey";
        width: parent.width
        height: 200
        anchors.top: parent.top
        anchors.topMargin: (parent.height-200)/2

        Rectangle {
            color:  "lightyellow";
            width: parent.width
            height: 10
            anchors.left: parent.left
            anchors.centerIn: parent;
        }


    }


// 中间十字路口
    Rectangle {
        id: loadCenter
        color:  "grey";
        width: 200
        height: 200
        anchors.centerIn: parent;
    }
    property real zebraCrossingLength: 35
    // 斑马线 水平方向
    Image {
        source: "qrc:/cars/zebraCrossing"
        anchors.right: loadCenter.left
        height: 120
        width: zebraCrossingLength
        y: window.height/2 - 120
    }
    Image {
        source: "qrc:/cars/zebraCrossing"
        anchors.right: loadCenter.left
        height: 120
        width: zebraCrossingLength
        y: window.height/2
    }
    Image {
        source: "qrc:/cars/zebraCrossing"
        anchors.left: loadCenter.right
        height: 120
        width: zebraCrossingLength
        y: window.height/2 - 120
    }
    Image {
        source: "qrc:/cars/zebraCrossing"
        anchors.left: loadCenter.right
        height: 120
        width: zebraCrossingLength
        y: window.height/2
    }
    // 斑马线 垂直方向
    Image {
        source: "qrc:/cars/zebraCrossing1"
        anchors.bottom: loadCenter.top
        width: 120
        height: zebraCrossingLength
        x: window.width/2
    }
    Image {
        source: "qrc:/cars/zebraCrossing1"
        anchors.bottom: loadCenter.top
        width: 120
        height: zebraCrossingLength
        x: window.width/2 - 120
    }
    Image {
        source: "qrc:/cars/zebraCrossing1"
        anchors.top: loadCenter.bottom
        width: 120
        height: zebraCrossingLength
        x: window.width/2
    }
    Image {
        source: "qrc:/cars/zebraCrossing1"
        anchors.top: loadCenter.bottom
        width: 120
        height: zebraCrossingLength
        x: window.width/2 - 120
    }



    // 车辆停止的范围
    property real speed1: 7
    property real speed2: 7
    property real speed3: 7
    property real speed4: 7
    property real fasterSpeed: 7
    property real slowerSpeed: 4
    property real slowerslowerSpeed: 2

    property real carLength: 100
    property real loadCenterLength: 200
    property real positionCheckLength: (window.width - loadCenterLength) / 2 - carLength
    property real positionCheckLength1: (window.width - loadCenterLength) / 2 + loadCenterLength
    property real positionCheckLengthRange: 50
    property real positionCheckHeight: (window.height - loadCenterLength) / 2 - carLength
    property real positionCheckHeight1: (window.height - loadCenterLength) / 2 + loadCenterLength
    // 左右方向的车辆
    Image {
        id: rightcar
        source: "qrc:/cars/rightcar"
        sourceSize.height: 100
        anchors.bottom: loadCenter.bottom
        x: -rightcar.width
        // 定时器组件
        Timer {
            id: moveTimer
            interval: 16 // 约60fps
            running: true // 默认开始运行
            repeat: true
            onTriggered: {
                if (rightcar.x < window.width) {
                    rightcar.x += speed1;
                } else {
                    rightcar.x = -rightcar.width;
                }
            }
        }
        // 定时器组件

        Timer {
           id: positionCheckTimer
           interval: 16 // 每50毫秒检查一次位置
           repeat: true // 重复触发
           running: true // 开始时即运行

           onTriggered: {
//               console.log(rightcar.x)
               if(rightcar.x > positionCheckLength-positionCheckLengthRange  && rightcar.x< positionCheckLength&&
                             trafficLightController.currentLightState === "Red"){

                    moveTimer.running = false;

                   } else if(trafficLightController.currentLightState === "Green") {
                   moveTimer.running = true;
                   speed1 = fasterSpeed;

                   } else if(rightcar.x > positionCheckLength-positionCheckLengthRange  && rightcar.x< positionCheckLength &&
                             (trafficLightController.currentLightState === "Yellow" ||
                              trafficLightController.currentLightState === "Red")) {
                   speed1 = slowerslowerSpeed;

                   } else {
                       speed1 = fasterSpeed;
                   }
           }
       }

    }
    Image {
        id: leftcar
        source: "qrc:/cars/leftcar"
        sourceSize.height: 100
        anchors.top: loadCenter.top
        // 定时器组件
        Timer {
            id: moveTimer1
            interval: 16 // 约60fps
            running: true // 默认开始运行
            repeat: true
            onTriggered: {
//                console.log(leftcar.x)
                if (leftcar.x < -leftcar.width) {
                    leftcar.x = window.width + leftcar.width;
                } else {
                    leftcar.x -= speed2;
                }
            }
        }
        // 定时器组件
        Timer {
           id: positionCheckTimer1
           interval: 16 // 每50毫秒检查一次位置
           repeat: true // 重复触发
           running: true // 开始时即运行

           onTriggered: {
//               console.log(leftcar.x)
               if(leftcar.x > positionCheckLength1  && leftcar.x< positionCheckLength1 + positionCheckLengthRange &&
                             trafficLightController.currentLightState === "Red"){

                    moveTimer1.running = false;

                   } else if(
                             trafficLightController.currentLightState === "Green") {

                   moveTimer1.running = true;
                   speed2 = fasterSpeed;

                   } else if(leftcar.x > positionCheckLength1  && leftcar.x< positionCheckLength1 + positionCheckLengthRange &&
                             (trafficLightController.currentLightState === "Yellow" ||
                              trafficLightController.currentLightState === "Red")) {
//                   console.log(leftcar.x)
                   speed2 = slowerslowerSpeed;

                   } else {
                   speed2 = fasterSpeed;
                   }
           }
       }

    }

    // 上下方向的车辆
    Image {
        id: downcar
        source: "qrc:/cars/downcar"
        sourceSize.height: 100
//        anchors.top : loadCenter.top
        anchors.left: loadCenter.left
        y: -downcar.height
        // 定时器组件
        Timer {
            id: moveTimer2
            interval: 16 // 约60fps
            running: true // 默认开始运行
            repeat: true
            onTriggered: {
                if (downcar.y < window.height) {
                    downcar.y += speed3;
                } else {
                    downcar.y = -downcar.height;
                }
            }
        }
        // 定时器组件
        Timer {
           id: positionCheckTimer2
           interval: 16 // 每50毫秒检查一次位置
           repeat: true // 重复触发
           running: true // 开始时即运行

           onTriggered: {
               if(downcar.y > positionCheckHeight-positionCheckLengthRange  && downcar.y< positionCheckHeight &&
                             trafficLightController1.currentLightState === "Red"){
//                   console.log(downcar.y)
                    moveTimer2.running = false;

                   } else if(trafficLightController1.currentLightState === "Green") {
                   moveTimer2.running = true;
                   speed3 = fasterSpeed;

                   } else if(downcar.y > positionCheckHeight-positionCheckLengthRange  && downcar.y< positionCheckHeight &&
                             (trafficLightController1.currentLightState === "Yellow" ||
                              trafficLightController1.currentLightState === "Red")) {
                   speed3 = slowerSpeed;

                   } else {
                       speed3 = fasterSpeed;
                   }
           }
       }

    }
    Image {
        id: upcar
        source: "qrc:/cars/upcar"
        sourceSize.height: 100
        anchors.right: loadCenter.right
        y: window.height
        // 定时器组件
        Timer {
            id: moveTimer3
            interval: 16 // 约60fps
            running: true // 默认开始运行
            repeat: true
            onTriggered: {
                if (upcar.y < -upcar.height) {
                    upcar.y = window.height+upcar.height;
                } else {
                    upcar.y -= speed4;
                }
            }
        }
        // 定时器组件
        Timer {
           id: positionCheckTimer3
           interval: 16 // 每50毫秒检查一次位置
           repeat: true // 重复触发
           running: true // 开始时即运行

           onTriggered: {
//               console.log(upcar.x)
               if(upcar.y > positionCheckHeight1  && upcar.y< positionCheckHeight1 + positionCheckLengthRange &&
                             trafficLightController1.currentLightState === "Red"){
                    moveTimer3.running = false;

                   } else if(trafficLightController1.currentLightState === "Green") {
                   moveTimer3.running = true;
                   speed4 = fasterSpeed;

                   } else if(upcar.y > positionCheckHeight1  && upcar.y< positionCheckHeight1 + positionCheckLengthRange &&
                             (trafficLightController1.currentLightState === "Yellow" ||
                              trafficLightController1.currentLightState === "Red")) {
                   speed4 = slowerSpeed;

                   } else {
                       speed4 = fasterSpeed;
                   }
           }

    }

}




    // 向右红绿灯
    LightLeftRight {
        id: lightright
        anchors.left: loadCenter.right
        y: window.height/2-loadCenter.height/8

    }
    // 向左红绿灯
    LightLeftRight {
        id: lightleft
        anchors.right: loadCenter.left
        y: window.height/2-loadCenter.height/8*3

    }
    // 向上红绿灯
    LightUpDown {
        id: lightup
        anchors.bottom: loadCenter.top
        x: window.width/2-loadCenter.height/8

    }

    // 向下红绿灯
    LightUpDown {
        id: lightdown
        anchors.top: loadCenter.bottom
        x: window.width/2-loadCenter.height/8*3

    }




}

App.cpp 

#include <QGuiApplication>
#include <QQmlApplicationEngine>
#include <QQmlContext>
#include "MyCppClass.h"
#include "MyListModel.h"
#include "TrafficLightController.h"
#include "TrafficLightController1.h"
#include <QIcon>

int main(int argc, char *argv[])
{
    QCoreApplication::setAttribute(Qt::AA_EnableHighDpiScaling);

    QGuiApplication app(argc, argv);

    app.setWindowIcon(QIcon(":/images/music.png"));

    // 创建TrafficLightController实例
    TrafficLightController trafficLightController;
    TrafficLightController1 trafficLightController1;

    QQmlApplicationEngine engine;

    // ... 添加更多项目
    MyListModel model;

    // 创建C++对象实例
    MyCppClass cppObject;

    // 将C++对象注册到QML上下文中
    engine.rootContext()->setContextProperty("myCppObject", &cppObject);
    engine.rootContext()->setContextProperty("myListModel", &model);
    // 将TrafficLightController实例设置为QML的上下文属性
    // 这样就可以在QML文件中通过id "trafficLightController" 访问它了
    engine.rootContext()->setContextProperty("trafficLightController", &trafficLightController);
    engine.rootContext()->setContextProperty("trafficLightController1", &trafficLightController1);

    const QUrl url(QStringLiteral("qrc:/App.qml"));
    QObject::connect(&engine, &QQmlApplicationEngine::objectCreated,
                     &app, [url](QObject *obj, const QUrl &objUrl) {
        if (!obj && url == objUrl)
            QCoreApplication::exit(-1);
    }, Qt::QueuedConnection);

    // 加载QML文件
    engine.load(url);

    return app.exec();
}
starter_yo~
关注
qml实现红绿灯切换功能
GG802312的博客
06-28 867
题目要求： 参考代码：https://download.csdn.net/download/y478225902/5260541 实现源码： import QtQuick 2.12 import QtQuick.Window 2.12 Window { visible: true width: 640 height: 480 color: "gray" title: qsTr("Hello World") //分配时间 221 Timer{
Quick QML 一个QML调用另一个文件夹下的QML方法
smartvxworks的博客
06-28 6135
通过import方式 import “./VedioScan/” //通过import引入VedioScan下面的所有qml文件 NKJ_container.qml文件引用VedioScan下的所有QML文件通过import “./VedioScan/” 实现
QML模拟交通信号灯
一个大佬的博客
07-06 319
【代码】QML模拟交通信号灯。
QML 实现一个简易的分页组件
龚建波
12-27 2344
当列表数据项较多的时候，会有分页展示的需求，可能需要展示数据总数、每页显示数、总页数、当前页数等。 因为数据可能是通过网络分页请求得到，或者本地数据会刷新，那么这些信息就得通过外部设置，组件只负责请求和展示页码信息就行了。点击某一页之后先预设置为该页按钮高亮，待数据返回后根据参数重新设置。 主要难点就在页码按钮数值的计算、显示隐藏上了，剩下的样式就根据需求调整。 效果展示： 主要实现代码： （github链接：https://github.com/gongjianbo/MyTestCode/t
QML | 实现一个转圈等待控件
@杭大大
05-26 1367
//RotatingWait.qml import QtQuick 2.7 import QtGraphicalEffects 1.0 Item { Rectangle { id: rect width: parent.width height: parent.height color: Qt.rgba(0, 0, 0, 0) radius: width / 2 border.width: wi...
QML实现一个登录框
龚建波
10-26 3318
0.设计 参考QQ的登陆框的布局，不过功能更简单。 主要加了两个辅助功能：密码保存（用的SQLite），以及监测键盘大小写状态。 1.实现细节 （1）密码保存操作的类主要功能是将用户信息保存到数据库，以及查询用户列表、查询用户信息等，主要接口如下： class LoginDBOperate : public QObject { Q_OBJECT //最近操作的账号列...
【QML】实现一个炫酷小键盘
ShrekLi
04-17 1464
个人声明：    由于之前发现有人将博客转载到私人博客上，并没有标记博文转载出处，所以在此将个人声明放置在最文章的最开头，希望转载的博主能够通知我一生，尊重一下别人的成果。以下内容，纯属个人观点，不喜勿喷。未经本人同意，不得私自转载。博客中出现的代码仅供学习参考，不得有其他用途。若文中存在纰漏，或读者有更好的建议，欢迎留言探讨。也可邮箱联系：yxyx_0212@163.com    前段时间，在知乎上看到了一篇关于Qt实现小键盘的博文，觉得挺有趣的，便照着玩了一下，其效果如图1所示。 图1 小键盘效果
QML用PathView实现一个轮播图
龚建波
12-12 1496
轮播图是一个常见的功能，在QML中，可以使用PathView来实现一个循环播放的轮播图组件。 默认情况，如果限制了加载个数，切换时第一帧会马上消失，第二帧才进入，这样会有断档的感觉。通过设置PathView中preferredHighlightBegin/End为0.5，这样当前选定的项位于路径的中间，就没有断档的感觉了。效果如下（为了测试，我没有clip，clip之后只有范围内的才可见）： ...
QML实现一个IP地址输入框
龚建波
07-17 2104
前言 以 Windows 网络设置里的 IP 地址输入框为参照，先看看他提供了哪些功能 输入数值范围不满足 0-255 ，或者该段的规定值，会弹错误提示框； 字符满三个后自动跳转到下一个 IP 段，或者按小数点也会进入下一段； 删除键删除完本段后再按删除自动去上一段进行删除 ； 按左右键如果光标在该段文本末尾或打头，光标自动进入相邻段； 如果选中了某个段的文本，则复制的是选中的文本，否则复制完整 IP 地址； 粘贴时如果是完整 IP 地址就覆盖每一项，如果是单个段数字则只覆盖当.
QML：第一个QML项目分析
01-27
QML是一种声明式语言，它提供了一组接口用来描述可视化组件以及他们之间的互动。...QML提供了一个高度可读的，声明式的，类似JSON语法的，并支持与JavaScript表达式相结合来达到动态属性的绑定。项
Qt Quick实现一个炫酷的折叠动画效果
03-19
本文将深入探讨如何使用Qt Quick实现一个炫酷的折叠动画效果，这通常用于增强应用的用户体验和视觉吸引力。 首先，理解Qt Quick的基础是至关重要的。Qt Quick是一种声明式语言，它允许开发者通过定义UI元素的属性和...
《QML和Qt Quick快速入门》示例源码
09-16
这个压缩包中的"src"文件夹很可能包含了多个子目录和文件，每个都对应书中介绍的一个或多个概念或功能。通过这些源码，你可以： 1. **了解基本语法**：QML使用JSON风格的语法，允许声明性地定义用户界面元素，如 ...
【C++】拆分详解 - string类
bubble_shadow的博客
09-23 1004
string类的文档介绍注：此处及下文部分，蓝色下划线标识文本均为超链接，点击即可跳转字符串是表示字符序列的类标准的字符串类提供了对此类对象的支持，其接口类似于标准字符容器的接口，但添加了专门用于操作单字节字符字符串的设计特性。string类是使用char(即作为它的字符类型，使用它的默认char_traits和分配器类型(关于模板的更多信息，请参阅basic_string)。
C++ 异步编程中：future与promise、packaged_task、async
zxf347085420的博客
09-23 987
std::launch::async | std::launch::deferred参数：是默认行为(可省略)。=》std::async真的是来帮忙的，你不用再想到底该怎么用std::future、std::promise和 std::packaged_task了，在已经有了td::future、std::promise和std::packaged_task的情况下，实现异步或多线程间通信，事实上std::promise::set_xxx函数会改变std::promise的状态为ready，
pyqt瀑布流布局
weixin_54217201的博客
09-21 482
最近研究瀑布流布局，发现都是收费的，所以只能自己写算法写布局。所以啥都不说直接上代码。
【C++】红黑树的封装——同时实现map和set
Mesar的博客
09-27 553
学习map和set，深入了解底层，通过模拟实现，学习高效数据结构与容器的关系，也帮助我们更好了解和使用容器
Python对于C语言使用者来说的反直觉特性
m0_62710548的博客
09-22 787
在编程领域，从一种语言转向另一种语言总是伴随着一系列的学习和调整。对于习惯了C语言严谨性的程序员来说，转向Python可能会遇到一些令人惊讶的特性。以下是我在短暂学习了一段时间python后察觉到的一些python的特性。
【C++】stack和queue的使用及注意事项
最新发布
wangnaisheng的专栏
09-28 466
【C++】stack和queue的使用及注意事项
QtQuick入门：解析首个QML项目
"QML：第一个QML项目分析" 在深入理解QML之前，我们首先需要知道QML是什么。QML（Qt Meta Language）是Qt框架的一部分，它是一种声明式的、用于构建用户界面的高级语言。QML的设计目标是让UI设计和开发变得更加直观...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值