移步换景 C++

最新推荐文章于 2024-08-30 10:02:47 发布
最新推荐文章于 2024-08-30 10:02:47 发布
阅读量109 收藏
点赞数 4
文章标签： 前端 javascript 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/a20130512yyc/article/details/140922965
版权

移步换景:通过输入←或→，让窗外风景移动

输入：

                                    *                                           
                                       *                                        
        *                                *                                 *    
                              *                 *                  *            
  *                                           *              *  __             *
                        *            *                        _/'`\             
                                                            /'     `\           
         __                                            ___/'         `\         
       /'  `\_                                       /'                \        
__- _--       \___-_- _--_- _--______- _--__- ___- _/'                   `\__--_
               \                                   /                            
                                                 -- _--______-                  
             _- _--_ __    _ _--_                                               
    -               -        -               - _-      _ __ - _--_-             
     -__                                                -              _--_     
                                                                                
                                                                                
                                                                                
                                                                                

                                                                                
                                                                                
                                                                                
                                 /||\                                           
                                 ||||                                           
                                 ||||                                           
                                 |||| /|\                                       
      /|\                   /|\  |||| |||                                       
     |||||                  |||  |||| |||                                       
     |||||                  |||  |||| |||                                       
 /\  |||||                  |||  |||| |||                                       
|||| |||||                  |||  |||||||/                                       
|||| |||||  /\              |||._||||~~'                                        
|||| ||||| ||||             \||||||||                                           
 \|`-'|||| ||||              `~~~||||                    ,,,                    
  \__ |||| ||||                  ||||                   {{}}} ,,,               
     ||||`-'|||                  ||||                    \|/ {{}}}              
     |||| ___/   \|/_\|/__\/__   |||| \|/__\|/\|/________\|/__\|/______\|/______
     |||||                       ||||                                           
     |||||

代码：111

#include <bits/stdc++.h>
#include "util.h"
using namespace std;

string background[] =
{
    R"L(                                    *                                           )L",
    R"L(                                       *                                        )L",
    R"L(        *                                *                                 *    )L",
    R"L(                              *                 *                  *            )L",
    R"L(  *                                           *              *  __             *)L",
    R"L(                        *            *                        _/'`\             )L",
    R"L(                                                            /'     `\           )L",
    R"L(         __                                            ___/'         `\         )L",
    R"L(       /'  `\_                                       /'                \        )L",
    R"L(__- _--       \___-_- _--_- _--______- _--__- ___- _/'                   `\__--_)L",
    R"L(               \                                   /                            )L",
    R"L(                                                 -- _--______-                  )L",
    R"L(             _- _--_ __    _ _--_                                               )L",
    R"L(    -               -        -               - _-      _ __ - _--_-             )L",
    R"L(     -__                                                -              _--_     )L",
    R"L(                                                                                )L",
    R"L(                                                                                )L",
    R"L(                                                                                )L",
    R"L(                                                                                )L",
};
const auto WIDTH = background[0].size();
const auto HEIGHT = sizeof(background)/sizeof(background[0]);

string foreground[] =
{
    R"L(                                                                                )L",
    R"L(                                                                                )L",
    R"L(                                                                                )L",
    R"L(                                 /||\                                           )L",
    R"L(                                 ||||                                           )L",
    R"L(                                 ||||                                           )L",
    R"L(                                 |||| /|\                                       )L",
    R"L(      /|\                   /|\  |||| |||                                       )L",
    R"L(     |||||                  |||  |||| |||                                       )L",
    R"L(     |||||                  |||  |||| |||                                       )L",
    R"L( /\  |||||                  |||  |||| |||                                       )L",
    R"L(|||| |||||                  |||  |||||||/                                       )L",
    R"L(|||| |||||  /\              |||._||||~~'                                        )L",
    R"L(|||| ||||| ||||             \||||||||                                           )L",
    R"L( \|`-'|||| ||||              `~~~||||                    ,,,                    )L",
    R"L(  \__ |||| ||||                  ||||                   {{}}} ,,,               )L",
    R"L(     ||||`-'|||                  ||||                    \|/ {{}}}              )L",
    R"L(     |||| ___/   \|/_\|/__\/__   |||| \|/__\|/\|/________\|/__\|/______\|/______)L",
    R"L(     |||||                       ||||                                           )L",
    R"L(     |||||                                                                      )L",
};

string ground[HEIGHT];
int main()
{
    clear();
    for (auto y=0; y<HEIGHT; y++) ground[y] = string(WIDTH, ' ');

    int direction = 0;
    int offset = 0;
    while (true) {
        if (offset%8==0) {
            if (direction==KEY_RIGHT) {
                for (auto y=0; y<HEIGHT; y++) {
                    auto t = background[y][0];
                    for (auto x=0; x<WIDTH-1; x++) {
                        background[y][x] = background[y][x+1];
                    }
                    background[y][WIDTH-1] = t;
                }
            } else if (direction==KEY_LEFT) {
                for (auto y=0; y<HEIGHT; y++) {
                    auto t = background[y][WIDTH-1];
                    for (auto x=WIDTH-1; x>0; x--) {
                        background[y][x] = background[y][x-1];
                    }
                    background[y][0] = t;
                }
            }
        }

        if (direction==KEY_RIGHT) {
            for (auto y=0; y<HEIGHT; y++) {
                auto t = foreground[y][0];
                for (auto x=0; x<WIDTH-1; x++) {
                    foreground[y][x] = foreground[y][x+1];
                }
                foreground[y][WIDTH-1] = t;
            }
        } else if (direction==KEY_LEFT) {
            for (auto y=0; y<HEIGHT; y++) {
                auto t = foreground[y][WIDTH-1];
                for (auto x=WIDTH-1; x>0; x--) {
                    foreground[y][x] = foreground[y][x-1];
                }
                foreground[y][0] = t;
            }
        }

        for (auto y=0; y<HEIGHT; y++) {
            for (auto x=0; x<WIDTH; x++) {
                ground[y][x] = foreground[y][x];
                if (ground[y][x]==' ') ground[y][x] = background[y][x];
            }
        }

        recursor();
        for (auto y=0; y<HEIGHT; y++) {
            for (auto x=0; x<WIDTH; x++) {
                cout << ground[y][x];
            }
            cout << '\n';
        }

        auto key = getkey();
        if (key==KEY_RIGHT) offset++;
        else if (key==KEY_LEFT) offset--;
        direction = key;
    }
}

可以运行一下 效果很好！！！！！

是漠北呀~
关注
  • 4
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
大话C++之：类型转换
sinat_38293503的博客
11-30 160
5分钟彻底讲清楚C++里4种不同的类型转换。 - `static_cast` 是最常用的类型转换，适用于**基本类型**之间的转换。 - `dynamic_cast` 主要用于**基类指针或引用**与**派生类指针或引用**之间的转换 。 - `const_cast` 用于修改或移除对象的**const**或**volatile**属性。 - `reinterpret_cast` 等效于C语言里强制类型转换。
C++基础入门（一）
热门推荐
Augenstern_QXL的博客
05-25 7万+
C++基础入门 0.写在前面 本篇笔记视频讲解地址：https://www.bilibili.com/video/BV1et411b73Z?p=1 笔记配合视频效果更好 外链图片上传失败已经解决 与各位共勉 用来复习回顾使用 1 C++初识 1.1 第一个C++程序 编写一个C++程序总共分为4个步骤 创建项目 创建文件 编写代码 运行程序 1.1.1 创建项目 ​ Visual Studio是我们用来编写C++程序的主要工具，我们先将它打开 1.1.2 创建文件 右键源文件，选择添加-&gt
【C++】C++入门
学了就忘是正常现象
09-21 3481
C++的第一步。
C++与C
移步换景的博客
10-07 115
C++中可以修饰的变量 相比C语言 增加了 bool 型变量 命名空间 using namespace 库的区别 例如 <stdio.h>和<iostream> <math.h> 和<cmath> C 语言完整继承了 C 语言的绝大多数库。C 语言中引用 math 库时的文件名是math.h,虽然在 C 语言中,依然可以这么写,但是在 C 中都应该这么写,即以c某某某的名字引入 #include <iomanip> 输入输出流格式 fixed和se
C++记忆化搜索
闻缺陷则喜何志丹
06-06 1586
记忆化搜索（Memoization Search）：是一种通过存储已经遍历过的状态信息，从而避免对同一状态重复遍历的搜索算法。 记忆化搜索是动态规划的一种实现方式。在记忆化搜索中，当算法需要计算某个子问题的结果时，它首先检查是否已经计算过该问题。如果已经计算过，则直接返回已经存储的结果；否则，计算该问题，并将结果存储下来以备将来使用。
C++（超详细讲解）| 初识C++
m0_74951730的博客
08-02 852
在这一篇初识C++的文章中，我会给大家带来一些我们经常用到的C++小技巧，并将其和C语言进行对比，让大家有更具象化的认识。我的目标是通过循序渐进的学习，让大家在享受编程乐趣的同时，掌握C++的核心知识，并能够独立编写出功能完善的程序。
C++核心编程(二)
Augenstern_QXL的博客
05-25 4万+
C++核心编程 0.写在前面 本篇笔记视频讲解地址：https://www.bilibili.com/video/BV1et411b73Z?p=1 笔记配合视频效果更好 外链图片上传失败已经解决，手动校正，如有错误和遗漏，可私信与评论进行指正，看到了会及时更改 与各位共勉 用来复习回顾使用 本阶段主要针对C++面向对象编程技术做详细讲解，探讨C++中的核心和精髓。 1 内存分区模型 C++程序在执行时，将内存大方向划分为4个区域 代码区：存放函数体的二进制代码，由操作系统进行管理的 全局区：存放全局变
C++动态规划
闻缺陷则喜何志丹
01-20 1853
动态规划（Dynamic Programming，DP）是运筹学的一个分支，是求解决策过程最优化的过程。每次决策依赖于当前状态，又随即引起状态的转移。一个决策序列就是在变化的状态中产生出来的，所以，这种多阶段最优化决策解决问题的过程就称为动态规划。
【C++】C++11
NeeEk0的博客
06-30 1174
本篇博客整理了C++11中较为实用的语法，以供读者查阅学习。
C++模板元编程（3）类型模板参数和模板模板参数
二进制君
04-04 3816
前面我们介绍了模板隐式实例化和显示实例化，今天介绍另外一个截然不同的概念，模板具体化。 来说说模板遇到的问题，也就是为什么要有模板具体化方法。模板函数自身有一定的局限性。由于其采用对对象类型的泛化处理，导致其在内部实现的细节上无法保证对所有类型的通用性。 假设定义了如下结构： struct job { char name[40]; double salary; int floor; }; 又假设你希望能够交换这两个结构的内容。原来的模板将使用下面的代码来完成交换： temp = a; a = b;
C++高性能服务器开发基础系列之【线程池】
存星的博客
02-01 1501
线程池 what 一种多线程的使用和管理模式，大多用于高并发服务器上，能够合理有效地利用多线程模型高并发服务器上的资源，多用于linux高并发服务器的场景下，与epoll模型结合使用。 why 服务器角度：解决多线程维护的问题。分为两方面，线程创建数量控制与线程资源的复用。在数量控制方面，线程过多会带来调度的额外开销，在线程池中通过主控线程可以合理维护线程数量；在线程资源的复用方面，避免了处理短时间任务时频繁创建销毁线程的消耗，处理完成任务后回归线程池，通过主控线程管理，充分利用内核资源。 ...
C++线程池
AllKillMan的专栏
11-22 1007
C++线程池 在面向对象编程中，创建和销毁对象是很费时间的，因为创建一个对象要获取内存资源或者其它更多资源。在Java中更是如此，虚拟机将试图跟踪每一个对象，以便能够在对象销毁后进行垃圾回收。所以提高服务程序效率的一个手段就是尽可能减少创建和销毁对象的次数，特别是一些很耗资源的对象创建和销毁。如何利用已有对象来服务就是一个需要解决的关键问题，其实这就是一些"池化资源"技术产生的原因。比如
【Visual C++】游戏开发笔记二十七 Direct3D 11入门级知识介绍
【浅墨的游戏编程Blog】毛星云（浅墨）的专栏
07-02 3万+
本系列文章由zhmxy555（毛星云）编写，转载请注明出处。http://blog.csdn.net/zhmxy555/article/details/7707628作者：毛星云    邮箱： happylifemxy@163.com    期待着与志同道合的朋友们相互交流上一节里我们介绍了在迈入DirectX 11的学习旅程之后第一个demo创建的全过程。但由于知识衔接的需要，我们的第一个dem
【Visual C++】游戏开发笔记十五 游戏人工智能（一） 运动型游戏AI
【浅墨的游戏编程Blog】毛星云（浅墨）的专栏
04-07 3万+
本系列文章由zhmxy555编写，转载请注明出处。  http://blog.csdn.net/zhmxy555/article/details/7434317作者：毛星云    邮箱： happylifemxy@qq.com    欢迎邮件交流编程心得我们常常听闻AI（Artificial Intelligence人工智能）这个名词，比如Dota里面的AI地图。写这篇文章的时候，最新版的Dota
Window Performance API
Bruce__taotao的博客
08-28 1444
Window Performance API 是一组浏览器提供的接口，用于收集和分析网页性能数据。它允许开发者精确地测量网页加载时间、资源加载时间、用户交互延迟等性能指标，从而优化用户体验。1. 主要接口1.1返回一个高精度时间戳，通常用于计算精确的时间差。例如，你可以用它来测量函数执行时间。使用场景: 精确计算代码段的执行时间。// 执行某个任务console.log(`执行时间:${// 执行某个任务 const end = performance . now();
前端的面试题
最新发布
本人小可爱
08-30 193
【代码】前端的面试题。
安防视频汇聚平台EasyCVR启动后无法访问登录页面是什么原因？
EasyCVR视频融合云平台的技术博客
08-27 547
以进程方式启动（./easycvr）时，清楚看到此时web端口【9004】被占用。更改端口后，EasyCVR视频汇聚平台可以正常访问了。
vue ref和reactive区别
灰海
08-25 5348
在第二个示例中，我们使用了reactive来创建一个名为state的响应式对象，它包含name和age两个属性。在模板中，我们通过{{ state.name }}和{{ state.age }}来显示state对象的属性值。在第一个示例中，我们使用了ref来创建一个名为count的响应式引用，它是一个简单的数字类型。在模板中，我们通过{{ count }}直接显示count的值，而不需要.value前缀，因为Vue的模板语法会自动处理ref的.value访问。
DSP28335控制的微位移步进电机精确定位系统
本文讨论了一种基于DSP的微位移步进电机控制方案，旨在实现测量装置的精准定位。系统使用DSP28335作为主控制器，控制最小步进角为1.8°的42步进电机，通过输出PWM脉冲波来驱动电机。控制精度高达线位移10μm，适用于...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值