项目三 迷宫

已于 2023-01-12 21:48:45 修改
阅读量86 收藏 2
点赞数
文章标签： c++ qt 学习
于 2023-01-10 10:19:38 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Saika145/article/details/128625250
版权

mainwindow.h

#ifndef MAINWINDOW_H
#define MAINWINDOW_H

#include <QWidget>
#include <QPushButton>
#include "mazewidget.h"

class MainWindow : public QWidget
{
    Q_OBJECT

public:
    explicit MainWindow(QWidget *parent = nullptr);

signals:

public slots:
    void changeWin();

private:
    QPushButton b;
    MazeWidget sub;

protected:
    void paintEvent(QPaintEvent*);
};

#endif // MAINWINDOW_H

mazewidget.h

#ifndef MAZEWIDGET_H
#define MAZEWIDGET_H

#include <QWidget>
#include <iostream>
#include <vector>
#include <queue>
#include <QTime>
#include <QLineEdit>
#include <QPushButton>
#include <QPainter>
#include <QLabel>
#include <QMessageBox>
#include <QDebug>
#include <QKeyEvent>
#include <QPixmap>
#include <QPen>
#include <QStack>

using namespace std;

namespace Ui
{
    class MazeWidget;
}
class Maze    //存放迷宫节点
{
    public:
    int i,j;    //迷宫节点的坐标
    int state;    //迷宫节点的状态，其中：0：墙；1：路：2：自动寻路路径
};
class Box1    //存放自动寻路时路径的信息
{
public:
    int i,j;
    int pre;    //前驱节点编号
    int num;    //当前节点编号
};

class MazeWidget : public QWidget
{
    Q_OBJECT

public:
    explicit MazeWidget(QWidget *parent = 0);
    ~MazeWidget();

    void paintEvent(QPaintEvent *);    //绘图事件
    void CreatMaze();    //创建迷宫
    void keyPressEvent(QKeyEvent*);    //键盘事件
    void FindShortWay();    //自动寻路
    void timerEvent(QTimerEvent*);    //定时器事件
    int score=0;

private:
    Ui::MazeWidget *ui;
    Maze **map;    //二维数组，存放迷宫地图
    vector<Maze> FinalPath;    //存放自动寻路的路径
    QStack<Maze> MazeStack;    //存放迷宫节点
    QStack<Box1> Box1Stack;    //存放自动寻路中处理后的节点
    queue<Box1> Box1Queue;    //存放自动寻路中未处理的节点
    int M,N;    //迷宫的行列数
    bool paint_flag;    //判断是否需要绘制画面
    QLineEdit *Xline;    //行编辑控件
    QLineEdit *Yline;    //列编辑控件
    QLabel *tips;    //显示提示的标签
    QLabel *recounts;    //显示“倒计时”图片的标签
    QPushButton *creatmazebtn;    //创建迷宫的按钮
    QPushButton *findshortwaybtn;    //自动寻路的按钮
    QLabel *time;    //显示时间的标签
    QLabel *toScore;    //显示得分的标签
    int X,Y;    //玩家的坐标
    int timerId;    //定时器ID
    bool find=false;    //判断自动寻路是否到达终点
    bool flag=false;    //判断有没有通路
    bool useFindRoad=false;    //判断游戏中是否使用了自动寻路功能

 private slots:
    void creatmazebtnSlot();
    void findshortwaybtnSlot();
    void counttimeSlot();
};

#endif // MAZEWIDGET_H

main.cpp

#include "mazewidget.h"
#include"mainwindow.h"
#include <QApplication>
#include<QtMultimedia/QMediaPlayer>
int main(int argc, char *argv[])
{
    QApplication a(argc, argv);
    MainWindow w;
    w.show();
    return a.exec();
}

mainwindow.cpp

#include "mainwindow.h"
#include <QPainter>
#include <QSound>

MainWindow::MainWindow(QWidget *parent) : QWidget(parent)
{
    this->setWindowTitle("开始界面");

    b.setParent(this);
    b.setGeometry(250,200,400,150);
    b.setStyleSheet("QPushButton{border-image:url(:/maze/image/start.png);border-radius:5px;}");

    QSound *sound=new QSound(":/maze/image/bgm.wav",this);
    sound->setLoops(-1);
    sound->play();

    this->setFixedSize(900,600);
    connect(&b,&QPushButton::released,this,&MainWindow::changeWin);
}

void MainWindow::changeWin()    //改变窗口
{
    sub.show();
    this->hide();
}

void MainWindow::paintEvent(QPaintEvent *)
{
    QPainter p(this);
    p.drawPixmap(0,0,width(),height(),QPixmap(":/maze/image/background.png"));
}

mazewidget.cpp

#include "mazewidget.h"
#include "ui_mazewidget.h"
#include <QSound>

MazeWidget::MazeWidget(QWidget *parent) :
    QWidget(parent),
    ui(new Ui::MazeWidget)
{
    ui->setupUi(this);
    paint_flag=false;
    M=35;
    N=35;
    X=3;
    Y=3;

    this->setWindowTitle("迷宫");
    this->setFixedSize((N+10)*20,(M+1)*20);
    this->setFocus(Qt::MouseFocusReason);

    Xline=new QLineEdit(this);
    Yline=new QLineEdit(this);
    Xline->setText("35");
    Yline->setText("35");
    Xline->setGeometry((N+2)*20+10,245,40,20);
    Yline->setGeometry((N+2)*20+70,245,40,20);

    creatmazebtn=new QPushButton(this);
    creatmazebtn->setText("开始游戏");
    creatmazebtn->setGeometry((N+2)*20,280,120,30);
    creatmazebtn->setStyleSheet("QPushButton{background-color:yellow;}");

    findshortwaybtn=new QPushButton(this);
    findshortwaybtn->setText("自动寻路");
    findshortwaybtn->setStyleSheet("QPushButton{background-color:rgb(250,128,114);}");
    findshortwaybtn->setGeometry((N+2)*20,20,120,30);
    findshortwaybtn->setEnabled(false);

    tips=new QLabel(this);
    tips->setText(" 地图边长范围:15~50");
    tips->setGeometry((N+2)*20,200,120,30);
    tips->setStyleSheet("QLabel{background-color:rgb(122,154,255)};font-weight:bold;");

    recounts=new QLabel(this);
    QPixmap pixmap;
    pixmap.load(":maze/image/counttime.jpg");
    recounts->setPixmap(pixmap);
    recounts->setScaledContents(true);
    recounts->setGeometry((N+2)*20,70,120,50);

    time=new QLabel(this);
    time->setGeometry((N+2)*20,100,120,20);

    toScore=new QLabel(this);
    toScore->setGeometry((N+2)*20,130,120,20);
    toScore->setStyleSheet("QLabel{background-color:rgb(250,128,114);font-size:22px;color:white;border-radius:5px;}");
    toScore->setText(QString("得分:%1").arg(score));

    map=new Maze*[M];    //初始化迷宫，节点全部设为墙壁
    for(int i=0;i<M;i++)
    {
        map[i]=new Maze[N];
    }
    for(int i=0;i<M;i++)
    {
        for(int j=0;j<N;j++)
        {
            map[i][j].state=0;
            map[i][j].i=i;
            map[i][j].j=j;
        }
    }

    connect(creatmazebtn,&QPushButton::clicked,this,&MazeWidget::creatmazebtnSlot);
    connect(findshortwaybtn,&QPushButton::clicked,this,&MazeWidget::findshortwaybtnSlot);
}

void MazeWidget::paintEvent(QPaintEvent *)
{
    QPainter painter(this);
    QPen pen;
    pen.setColor(QColor(Qt::yellow));
    pen.setStyle(Qt::CustomDashLine);
    painter.setPen(pen);

    for(int i=FinalPath.size()-1;i>=0;i--)
    {
        map[FinalPath.at(i).i][FinalPath.at(i).j].state=2;
        if(FinalPath.at(i).i==X&&FinalPath.at(i).j==Y)    //清除走过的路的寻路痕迹
        {
            map[FinalPath.at(i).i][FinalPath.at(i).j].state=1;
            FinalPath.pop_back();
        }
    }

    if(paint_flag)
    {
        for(int i=0;i<M;i++)
        {
            for(int j=0;j<N;j++)
            {
                if(i==X&&j==Y)    //画角色
                {
                    painter.drawPixmap(j*20,i*20,20,20,QPixmap(":maze/image/character.png"));
                }
                else if(i==M-2&&j==N-2)    //画金币
                {
                    painter.drawPixmap(j*20,i*20,20,20,QPixmap(":maze/image/gold.png"));
                }
                else
                {
                    switch(map[i][j].state)
                    {
                    case 0:    //画墙壁
                        painter.drawPixmap(j*20,i*20,20,20,QPixmap(":maze/image/wall.jpg"));
                        break;
                    case 1:    //画道路
                        painter.drawPixmap(j*20,i*20,20,20,QPixmap(":maze/image/road.png"));
                        break;
                    case 2:    //画自动寻路路径
                        painter.setBrush(QBrush(QColor(250,128,114),Qt::SolidPattern));
                        painter.drawRect(QRect(j*20,i*20,20,20));
                        break;
                    }
                }
            }
        }
    }
}

MazeWidget::~MazeWidget()
{
    delete ui;
}

void MazeWidget::CreatMaze()    //创建迷宫节点矩阵
{
    int i=3,j=3;
    map[i][j].state=1;

    int randDir=0;

    Maze temp;
    temp.i=i;
    temp.j=j;
    temp.state=1;

    bool Up=true;    //判断各个方向能否到达
    bool Down=true;
    bool Right=true;
    bool Left=true;

    while(1)    //不断生成迷宫节点，直至栈为空
    {
        temp.i=i;
        temp.j=j;
        randDir=qrand()%4;    //获取随机方向：0：上；1：右；2：下；3：左

        switch(randDir)
        {
        case 0:
            if(Up&&i>2&&map[i-2][j].state==0)
            {
                MazeStack.push(temp);
                map[i-2][j].state=1;
                map[i-1][j].state=1;
                i=i-2;

                int rand;
                rand=qrand()%10;
                if(rand>3)
                {
                    Up=true;
                    Right=true;
                    Down=true;
                    Left=true;
                }
                else
                {
                    Up=false;
                    Right=false;
                    Down=false;
                    Left=false;
                }
            }
            else
            {
                Up=false;
            }
            break;
          case 1:
            if(Right&&j<N-3&&map[i][j+2].state==0)
            {
                MazeStack.push(temp);
                map[i][j+2].state=1;
                map[i][j+1].state=1;
                j=j+2;

                int rand;
                rand=qrand()%10;
                if(rand>3)
                {
                    Up=true;
                    Right=true;
                    Down=true;
                    Left=true;
                }
                else
                {
                    Up=false;
                    Right=true;
                    Down=false;
                    Left=true;
                }
            }
            else
            {
                Right=false;
            }
            break;
          case 2:
            if(Down&&i<M-3&&map[i+2][j].state==0)
            {
                MazeStack.push(temp);
                map[i+2][j].state=1;
                map[i+1][j].state=1;
                i=i+2;

                int rand;
                rand=qrand()%10;
                if(rand>3)
                {
                    Up=true;
                    Right=true;
                    Down=true;
                    Left=true;
                }
                else
                {
                    Up=false;
                    Right=false;
                    Down=false;
                    Left=false;
                }
            }
            else
            {
                Down=false;
            }
            break;
        case 3:
            if(Left&&j>2&&map[i][j-2].state==0)
            {
                MazeStack.push(temp);
                map[i][j-2].state=1;
                map[i][j-1].state=1;
                j=j-2;

                Up=true;
                Right=true;
                Down=true;
                Left=true;
            }
            else
            {
                Left=false;
            }
            break;
        }

        if(!Up&&!Down&&!Right&&!Left)    //四个方向都不能创建新节点
        {
            if(!MazeStack.empty())    //回溯
            {
                i=MazeStack.top().i;
                j=MazeStack.top().j;
                MazeStack.pop();
                Up=true;
                Down=true;
                Right=true;
                Left=true;
            }
            else return;
        }
    }
}

void MazeWidget::creatmazebtnSlot()    //创建迷宫的槽函数
{
    if(Xline->text().toInt()>=15&&Yline->text().toInt()>=15&&Xline->text().toInt()<=50&&Yline->text().toInt()<=50)
    {
        M=Xline->text().toInt();    //重新配置画面元素
        N=Yline->text().toInt();
        if(M%2==0) M--;
        if(N%2==0) N--;
        this->setFixedSize((N+10)*20,(M+1)*20);
        Xline->setGeometry((N+2)*20+10,245,40,20);
        Yline->setGeometry((N+2)*20+70,245,40,20);
        creatmazebtn->setGeometry((N+2)*20,280,120,30);
        findshortwaybtn->setGeometry((N+2)*20,20,120,30);
        findshortwaybtn->setEnabled(true);
        tips->setGeometry((N+2)*20,200,120,30);
        recounts->setGeometry((N+2)*20,70,120,50);
        time->setGeometry((N+2)*20,130,120,20);
        time->setStyleSheet("QLabel{background-color:rgb(200,101,202);font-size:25px;color:white;}");
        toScore->setGeometry((N+2)*20,160,120,20);
        toScore->setText(QString("得分:%1").arg(score));
        FinalPath.clear();
        this->setFocus(Qt::MouseFocusReason);

        X=1;    //初始化
        Y=1;
        map=new Maze*[M];
        for(int i=0;i<M;i++)
        {
            map[i]=new Maze[N];
        }
        for(int i=0;i<M;i++)
        {
            for(int j=0;j<N;j++)
            {
                map[i][j].state=0;
                map[i][j].i=i;
                map[i][j].j=j;
            }
        }

        this->CreatMaze();
        paint_flag=true;
        update();
    }
    else
    {
       QMessageBox::information(this,"错误","输入的边长不在限制范围内！",QMessageBox::Yes);
       Xline->clear();
       Yline->clear();
    }

    this->killTimer(timerId);
    timerId=this->startTimer(1000);

    this->findshortwaybtnSlot();    //保证通路
    useFindRoad=false;
    FinalPath.clear();
    while(!Box1Queue.empty())
    {
         Box1Queue.pop();
    }
    if(flag==false) creatmazebtnSlot();

    disconnect(creatmazebtn,&QPushButton::clicked,this,&MazeWidget::creatmazebtnSlot);
}

void MazeWidget::keyPressEvent(QKeyEvent *e)
{
    int temp;
    if(e->key()==Qt::Key_W)
    {
        temp=X-1;
        if(temp && map[temp][Y].state) X=temp;
    }
    else if(e->key()==Qt::Key_S)
    {
        temp=X+1;
        if(temp<M-1 && map[temp][Y].state) X=temp;
    }
    else if(e->key()==Qt::Key_A)
    {
        temp=Y-1;
        if(temp && map[X][temp].state) Y=temp;
    }
    else if(e->key()==Qt::Key_D)
    {
        temp=Y+1;
        if(temp<N-1 && map[X][temp].state) Y=temp;
    }

    if(X==M-2 && Y==N-2)    //到达终点
    {
        QSound *sound=new QSound(":/maze/image/getgold.wav",this);
        sound->setLoops(1);
        sound->play();

        if(!useFindRoad)
        {
            QMessageBox::information(this,"恭喜","您获得了一枚金币！",QMessageBox::Yes);
            toScore->setText(QString("得分:%1").arg(++score));
        }
        else
        {
            QMessageBox::information(this,"提示","您使用了自动寻路功能\n因此分数不增加！",QMessageBox::Yes);
            useFindRoad=false;
        }

        for(int i=0;i<M;i++)
        {
            for(int j=0;j<N;j++)
            {
                map[i][j].state=0;
            }
        }

        FinalPath.clear();
        this->creatmazebtnSlot();
        this->counttimeSlot();
    }
    update();
}

void MazeWidget::FindShortWay()    //自动寻路
{
    FinalPath.clear();    //删除已有自动寻路结果
    while(!Box1Queue.empty())
    {
         Box1Queue.pop();
    }

    Maze maze[M][N];
    int i,j;
    for(i=0;i<M;i++)
    {
        for(j=0;j<N;j++)
        {
            maze[i][j].i=i;
            maze[i][j].j=j;
            maze[i][j].state=map[i][j].state;
        }
    }

    int t=0,pos=0;
    Box1 box;
    box.i=X;
    box.j=Y;
    box.pre=-1;
    box.num=t;
    Box1Queue.push(box);
    maze[X][Y].state=-1;    //-1：已走过该节点；1：未走过该节点
    Maze temp;
    find=false;
    flag=false;

    while(!Box1Queue.empty()&&!find)
    {
        i=Box1Queue.front().i;    //把队首的节点入栈
        j=Box1Queue.front().j;
        box.i=i;
        box.j=j;
        box.num=Box1Queue.front().num;
        box.pre=Box1Queue.front().pre;
        Box1Stack.push(box);

        if(i==M-2&&j==N-2)    //到达终点
        {
            find=true;
            flag=true;

            while(!Box1Stack.empty())    //按栈原路返回
            {
                temp.i=Box1Stack.top().i;
                temp.j=Box1Stack.top().j;
                temp.state=1;
                FinalPath.push_back(temp);
                pos=Box1Stack.top().pre;
                while(!Box1Stack.empty()&&pos!=Box1Stack.top().num)
                {
                    Box1Stack.pop();
                }
            }

        }

        int dire=0;
        for(dire=0;dire<4;dire++)    //0：上；1：右；2：下；3：左
        {
            switch(dire)
            {
            case 0:
                i=Box1Queue.front().i-1;
                j=Box1Queue.front().j;
                break;
            case 1:
                i=Box1Queue.front().i;
                j=Box1Queue.front().j+1;
                break;
            case 2:
                i=Box1Queue.front().i+1;
                j=Box1Queue.front().j;
                break;
            case 3:
                i=Box1Queue.front().i;
                j=Box1Queue.front().j-1;
                break;
            }
            if(maze[i][j].state==1)    //还未走过
            {
                t++;
                box.i=i;
                box.j=j;
                box.num=t;
                box.pre=Box1Queue.front().num;
                Box1Queue.push(box);
                maze[i][j].state=-1;
            }
        }
        Box1Queue.pop();
    }
}

void MazeWidget::findshortwaybtnSlot()    //自动寻路的槽函数
{
    useFindRoad=true;
    for(int i=0;i<M;i++)
    {
        for(int j=0;j<N;j++)
        {
            if(map[i][j].state==2)
            {
                map[i][j].state=1;
            }
        }
    }
    FindShortWay();
    update();
}

void MazeWidget::timerEvent(QTimerEvent *)
{
    counttimeSlot();
}

void MazeWidget::counttimeSlot()
{
    static int sec=180;
    time->setText(QString("%1").arg(sec--));
    if(time->text().toInt()==0)
    {
        this->killTimer(timerId);
        int ret=QMessageBox::information(this,"游戏结束！","您本轮游戏获得的金币数为："+QString::number(score)+"。\n点击确认键开始新一轮的游戏！",QMessageBox::Yes);
        if(ret==QMessageBox::Yes)
        {
            this->creatmazebtnSlot();
            connect(creatmazebtn,&QPushButton::clicked,this,&MazeWidget::creatmazebtnSlot);
        }
        sec=180;
        score=0;
        toScore->setText(QString("得分:%1").arg(score));
    }
}

Saika145
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
项目三 迷宫游戏
m0_73231867的博客
02-25 192
qt实现迷宫游戏
计算机软件技术实习 项目三 迷宫
lb372895669的博客
12-19 2351
一、实验内容 1)迷宫游戏是非常经典的游戏，在该题中要求随机生成一个迷宫，并求解迷宫； 2）要求查找并理解迷宫生成的算法，并尝试用两种不同的算法来生成随机的迷宫。 3）要求迷宫游戏支持玩家走迷宫，和系统走迷宫路径两种模式。玩家走迷宫，通过键盘方向键控制，并在行走路径上留下痕迹；系统提示迷宫路径要求基于A*算法实现，输出玩家当前位置到迷宫出口的最优路径。设计交互友好的游戏图形界面。 二、语言、数据结构、算法 java swing 栈 树 A* 三、平台 eclipse 四、源代...
软件技术实习项目三 迷宫
qq_57752978的博客
12-24 8172
项目准备 需求分析 1.prime算法生成迷宫 2.A*算法实现自动寻路 编程语言及开发工具 JAVA，IDEA 项目软件概述 界面 功能 1.能随机生成迷宫 2.自动寻路功能 代码 Main import javax.swing.*; public class Main { public static void main(String[] args) { JFrame frame = new JFrame(); frame.setT.
项目三 Java开发迷宫游戏
m0_62884267的博客
12-14 4537
一.项目预习： 思考过程： 　　迷宫由一个一个格子组成，要求从入口到出口只有一条路径. 　　通过树实现是比较容易的，从根节点到每一个子节点都只有一条路径。假设入口是根节点，出口是树中某个子节点，那么，从根节点到该子节点的路径肯定是唯一的。 　　所以构造一棵树把所有的格子都覆盖到，也就能够做出一个迷宫了。 　　要求树的父节点和子节点必须是界面上相邻的格子。 　　在界面显示时，父节点和子节点之间共用的边不画，其他的边都画出来，就能画出一个迷宫。 1.树的表示： 　　要实现这棵树，那么每个树节点里
计算机软件实习项目三——迷宫
weixin_50472901的博客
09-24 248
一、构建随机迷宫 应用不相交集合构建迷宫的算法简要描述如下：给定一个 N X N 的方格，初始时每个方格的四面都是墙（walls），如图所示，其中的 S 是迷宫的开始处，F 是迷宫的结束处。NN 迷宫的 N2 个方格 0，1，…，N2-1 初始时每个方格自己成为一个等价类，即{0}，{1}，…，{N2-1}。生成随机迷宫 的方法是随机选择一个内部墙（连接两个相邻方格的墙），如果该内部墙关联的 两个相邻的方格属于不同的等价类就将该墙除去，在除去该墙的同时将这两个等 价类合并。
实验三 迷宫游戏
qq_52938917的博客
12-20 2171
迷宫游戏设计开发
实验项目3 基于A*算法的迷宫游戏开发
Gyf1030_的博客
12-23 380
实验内容 （1）迷宫游戏是非常经典的游戏，在该题中要求随机生成一个迷宫，并求解迷宫； （2）要求游戏支持玩家走迷宫，和系统走迷宫路径两种模式。玩家走迷宫，通过键盘方向键控制，并在行走路径上留下痕迹；系统走迷宫路径要求基于A*算法实现，输出走迷宫的最优路径并显示； （3）设计交互友好的游戏图形界面。 实验平台 通过高级程序设计语言（JAVA）实现。 相关知识 ①JAVA 具体步骤 ...
Java迷宫项目代码
Yan_tutou的博客
11-10 1589
java迷宫项目 项目介绍： 一个网格迷宫由n行m列的单元格组成，每个大院要么是空地（用0表示），要么是障碍物（用1表示）。你的任务是找一条从起点到终点的移动序列，其中只能上下左右移动到相邻单元格。任何时候都不能在有障碍物的单元格中，也不能走到迷宫之外。起点为左上角和终点右下角。 项目功能： 解决迷宫路径查找问题，寻找一条从左上角迷宫入口到右下角迷宫出口的一条有效路径，0代表可走，1代表不能行走，找到请输出最终的迷宫和路径信息，找不到请输出不存在有效路径。 项目所用知识点： 采用Java面向对象思想，二维数
实验三迷宫
weixin_57578282的博客
12-28 1593
。。
OpenGL-三维迷宫游戏的设计与实现
关注网络安全、云原生安全
06-23 5182
目录 游戏安装使用演示视频 部分游戏截图 数据库恢复（mysql 5.7.20） 代码使用 Qt部分（Qt5.9.1） VS部分（VS2015） 代码调试 全部资源 这是现代OpenGL入门教程的最后一篇文章，学习OpenG至今，最终以一个游戏作为结束，注意，最后的打包使用的是HofoSetUp软件，不是教程中添加依赖形成单一文件的那种方法。 游戏安装使用演示视频 链接：ht...
basic-program.rar_三维迷宫
09-14
《三维迷宫编程基础》 在计算机科学领域，三维迷宫是一种引人入胜的图形化游戏或模拟，它能够锻炼玩家的空间想象能力和逻辑思维能力。对于初学者来说，掌握三维迷宫的编程技巧不仅可以提升编程技能，还能为后续的...
易语言三维迷宫.rar
02-23
《易语言三维迷宫》是一款基于易语言编程的三维迷宫探索软件，它为用户提供了独特的虚拟迷宫体验。易语言是一种中文编程语言，旨在降低编程门槛，让计算机技术更加普及。通过这款软件，我们可以深入理解和学习易语言...
VB三维迷宫源码
03-03
【VB三维迷宫源码】是一个基于Visual Basic 6.0（VB6）开发的程序，它展示了如何在二维屏幕上创建并实现一个交互式的三维迷宫游戏。在VB6中，尽管它本身并不直接支持三维图形渲染，但通过巧妙的算法和编程技巧，...
Unity3D迷宫项目C#
01-20
《Unity3D迷宫项目C#详解》 Unity3D是一款强大的跨平台游戏开发引擎，以其易用性、高效性和广泛支持的平台而备受开发者喜爱。在这个“Unity3D迷宫项目”中，我们将深入探讨如何利用C#编程语言来构建一个迷宫探索类...
自制迷宫式三分频音箱
07-30
在这个项目中，作者对原有的惠威音箱套件进行了三次改造，最终确定为迷宫式结构。音箱的中高音部分采用了封闭式设计，这种设计可以有效地避免中高频单元的声波干涉，确保声音的纯净度。封闭式音箱内部无空气流动，...
使用vtkRenderer创建的显示点云的窗口如何刷新(QT/C++)
qq_19319481的博客
08-09 366
使用vtkRenderer创建的显示点云的窗口如何刷新(QT/C++)
C语言一维数组(含数组二分查找)
hdxbufcbjuhg的博客
08-09 1238
在⼀个升序的数组中查找指定的数字n，很容易想到的⽅法就是遍历数组，但是这种⽅法效率⽐较低。比如我们之前写的猜数字游戏，会生成一个随机数来让玩家猜，范围是1~100，那玩家会从1开始一个一个猜吗，不会吧，那样就太慢了，我们一般会从整体的一半开始猜，比如猜50，告诉你大了还是小了，这样只需要一步就可以排除庞大数字中的一半，比如假设猜1 ~ 10000，猜5000后就可以知道猜大了还是小了，直接排除了5000个数字，效率很快，这就是⼆分查找，也叫折半查找。
【C++】类的默认成员函数，构造函数、析构函数、拷贝构造函数、运算符重载
最新发布
2402_82757055的博客
08-10 924
这篇我们继续学习C++类和对象部分，大概会说一下类的一些默认成员函数，构造函数、析构函数、拷贝构造函数、赋值运算符重载这些知识。
C语言断言进阶篇：全面总结与实战技巧
极客代码
08-10 484
断言是一种用于验证程序中某个条件是否为真的语句。如果条件为假，程序会触发一个错误，通常会导致程序终止。断言主要用于开发和测试阶段，以帮助开发者发现和修正错误。在某些情况下，默认的assert宏可能无法满足我们的需求。if (!abort();= NULL);在这个自定义断言宏中，我们输出了更多的错误信息，包括失败的断言表达式、函数名、文件名和行号，方便我们定位错误。本文系统且全面地总结了C语言中的断言机制，包括断言的定义、作用、实现以及在实战中的运用。
基于ARM7芯片的智能迷宫小车设计
"智能迷宫小车设计说明书和科技创新三小车自动走迷宫组实验报告" 在这份资料中，我们关注的是智能迷宫小车的设计与实现，它结合了电子工程、计算机科学以及机械工程等多个领域的技术。智能迷宫小车的核心是采用ST...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值