第15章 《乐趣》Page355~375 纹理，渲染器，代码简化版

已于 2023-12-21 21:13:32 修改
阅读量405 收藏 9
点赞数 5
分类专栏： 《白话C++》学习 《白话C++》第15章 乐趣 SDL 文章标签： c++
于 2023-12-18 00:56:11 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yanzhenxi/article/details/135053165
版权

运行效果：全屏了

简化之后的代码如下：

//main.cpp
#include <iostream>
#include <SDL2/SDL.h>
#include "sdl_initiator.hpp"
#include "sdl_error.hpp"
#include "sdl_window.hpp"
#include "sdl_surface.hpp"
#include "sdl_renderer.hpp"
#include "sdl_texture.hpp"

using namespace std;

//加载图片为纹理，并设置透明色
SDL_Texture* LoadBMPTexture(SDL_Renderer* renderer
                           , char const* filename
                           , Uint8 key_r, Uint8 key_g, Uint8 key_b)
{
    sdl2::BitmapSurface bmp(filename);
    if(!bmp)
    {
        return nullptr;
    }
    bmp.EnableColorKey(key_r, key_g, key_b, 0);
    return sdl2::Texture(renderer, bmp._surface).Release();
}
//加载图片为纹理，不透明，不混色
SDL_Texture* LoadBMPTexture(SDL_Renderer* renderer
                            , char const* filename)
{
    sdl2::BitmapSurface bmp(filename);
    if(!bmp)
    {
        return nullptr;
    }

    return sdl2::Texture(renderer, bmp._surface).Release();
}
//加载图片为纹理，并设置透明色和混色
SDL_Texture* LoadBMPTexture(SDL_Renderer* renderer
                , char const* filename
                , Uint8 key_r, Uint8 key_g, Uint8 key_b
                , Uint8 alpha_mod
                , SDL_BlendMode blend_mode = SDL_BLENDMODE_BLEND)
{
    sdl2::BitmapSurface bmp(filename);
    if(!bmp)
    {
        return nullptr;
    }
    bmp.EnableColorKey(key_r, key_g, key_b, 0);
    bmp.SetAlphaMod(alpha_mod);
    bmp.SetBlendMode(blend_mode);
    return sdl2::Texture(renderer, bmp._surface).Release();
}
int main(int argc, char* argv[])
{
    sdl2::Initiator::Instance().Init(SDL_INIT_VIDEO
                                     | SDL_INIT_AUDIO
                                     | SDL_INIT_EVENTS
                                     | SDL_INIT_TIMER);

    if(!sdl2::Initiator::Instance())//重载转换符
    {
        cerr << "初始化就出错，没得玩了！"
             << sdl2::last_error() << endl;
    }

    //创建并居中显示宽640，高480的游戏窗口
    sdl2::Window wnd("hello sdl"
                     , sdl2::WindowPosition()
                     , 640, 480
                     //使用空的特性标志
                     , sdl2::WindowFlags().FullScreenDesktop());

    if(!wnd)
    {
        cerr << sdl2::last_error() << endl;
        return -1;
    }

    //准备窗口的渲染器
    sdl2::Renderer renderer(wnd._window);
    if(!renderer)
    {
        cerr << sdl2::last_error() << endl;
        return -1;
    }
    //重要！修改缩放质量配置
    sdl2::RendererDriver::HintScaleQuality();
    //重要！设置虚拟大小
    renderer.SetLogicalSize(640, 480);

    //准备背景图(不需要透明和混色)
    sdl2::Texture bkgnd(LoadBMPTexture(renderer._renderer, "bkgnd.bmp"));

    if(!bkgnd)
    {
        cerr << sdl2::last_error() << endl;
        return -1;
    }

    //准备小马图，透明色为白色
    sdl2::Texture horse(LoadBMPTexture(renderer._renderer
                                       , "sdl.bmp"
                                       , 0xff, 0xff, 0xff));
    if(!horse)
    {
        cerr << sdl2::last_error() << endl;
        return -1;
    }

    //准备白云图纹理，透明色为红色，不透明度188（0~255）
    sdl2::Texture cloud(LoadBMPTexture(renderer._renderer
                                       , "cloud.bmp"
                                       , 0xff, 0, 0, 188));
    if(!cloud)
    {
        cerr << sdl2::last_error() << endl;
        return -1;
    }
    //事件循环
    bool Q = false;
    while(!Q)//一直循环，直到Q为真
    {
        SDL_Event event;
        //会将队列中拖出的event数据存储到event中
        while(SDL_PollEvent(&event))
        {
            switch(event.type)
            {
                case SDL_QUIT:
                    Q = true;
                    break;
            }
        }//内循环

        /*外循环：贴骏马图*/
        //贴背景->窗口
        renderer.CopyFrom(bkgnd._texture);

        //贴第一朵白云
        SDL_Rect cloud_rect_1{200, 20, 156, 78};
        renderer.CopyFrom(cloud._texture, nullptr, &cloud_rect_1);

        //贴第二朵白云
        SDL_Rect cloud_rect_2{340, 6, 156, 78};
        renderer.CopyFrom(cloud._texture, nullptr, &cloud_rect_2);
        //贴骏马
        SDL_Rect dst_rect{86, 65, 468, 350};
        renderer.CopyFrom(horse._texture, nullptr, &dst_rect);

        renderer.Present();
        SDL_Delay(1);//防止cpu占用率太高
//        Q = true; //开发过程中，为方便程序退出，暂时这样
    }//外循环

    return 0;
}

//sdl_error.cpp
#include "sdl_error.hpp"

namespace sdl2
{

char const* last_error()
{
    return SDL_GetError();
}

}//sdl2

//sdl_error.hpp
#ifndef SDL_ERROR_HPP_INCLUDED
#define SDL_ERROR_HPP_INCLUDED
#include <SDL2/SDL.h>

namespace sdl2
{
char const* last_error();
}


#endif // SDL_ERROR_HPP_INCLUDED


//sdl_initiator.hpp
#ifndef SDL_INITIATOR_HPP_INCLUDED
#define SDL_INITIATOR_HPP_INCLUDED

namespace sdl2
{

struct Initiator
{
private: //单例模式，外界无需使用构造函数
    Initiator()
        : _init_result(-1)
    {

    }

public:
    static Initiator& Instance()
    {
        static Initiator Instance;
        return Instance;
    }

    ~Initiator()
    {
        SDL_Quit();
    }

    void GetVersion(Uint8& major, Uint8& minor, Uint8& patch)
    {
        SDL_version ver;
        SDL_GetVersion(&ver);

        major = ver.major;
        minor = ver.minor;
        patch = ver.patch;
    }

    bool Init(Uint32 flags = SDL_INIT_EVERYTHING)
    {
        _init_result = SDL_Init(flags);
        return 0 == _init_result;
    }

//    bool operator bool()
    explicit operator bool() const
    {
        return _init_result == 0;
    }

private:
    int _init_result;
};//Initiator

}//sdl2

#endif // SDL_INITIATOR_HPP_INCLUDED


//sdl_renderer.hpp
#ifndef SDL_RENDERER_HPP_INCLUDED
#define SDL_RENDERER_HPP_INCLUDED

namespace sdl2
{
//渲染驱动（方法均为静态）
struct RendererDriver
{
    static bool HintScaleQuality(char const* quality = "linear")
    {
        return SDL_SetHint(SDL_HINT_RENDER_SCALE_QUALITY, quality);
    }
};

struct Renderer
{
    Renderer(SDL_Window* window, int index = -1, Uint32 flags = 0)
    {
        _renderer = SDL_CreateRenderer(window, index, flags);
    }

    ~Renderer()
    {
        SDL_assert(_renderer != nullptr);
        SDL_DestroyRenderer(_renderer);
    }

    bool SetLogicalSize(int w, int h)
    {
        SDL_assert(_renderer != nullptr);
        return 0 == SDL_RenderSetLogicalSize(_renderer, w, h);
    }

    bool CopyFrom(SDL_Texture* src_texture
                  , const SDL_Rect* src_rect = nullptr
                  , const SDL_Rect* dst_rect = nullptr)
    {
        SDL_assert(_renderer != nullptr);
        SDL_assert(src_texture != nullptr);
        return 0 == SDL_RenderCopy(_renderer, src_texture, src_rect, dst_rect);
    }

    void Present()
    {
        SDL_assert(_renderer != nullptr);
        SDL_RenderPresent(_renderer);
    }
    explicit operator bool() const
    {
        return _renderer != nullptr;
    }

    SDL_Renderer* _renderer;
};//Renderer

}//sdl2

#endif // SDL_RENDERER_HPP_INCLUDED


//sdl_surface.hpp
#ifndef SDL_SURFACE_HPP_INCLUDED
#define SDL_SURFACE_HPP_INCLUDED

namespace sdl2
{

struct Surface
{

    //代管外部创建好的surface指针
    explicit Surface(SDL_Surface* surface)
        : _surface(surface)
    {

    }
    /*父类的析构函数使用虚函数的主要原因是为了确保多态时的正确清理。
      在C++中，析构函数主要用于释放动态分配的资源。如果父类的析构函数不是虚函数，
      那么当使用子类指针删除父类对象时，由于没有动态绑定（晚绑定），
      只会调用父类的析构函数，而不会调用子类的析构函数。
      这样，子类中的资源可能不会被正确释放，导致内存泄漏或其他问题。

     如果父类的析构函数是虚函数，那么当使用子类指针删除父类对象时，
     会根据实际对象的类型动态调用相应的析构函数。这样，既可以释放父类占用的资源，
     又可以释放子类占用的资源，确保资源的正确释放。
     因此，为了确保多态时的正确清理，父类的析构函数应该声明为虚函数。*/
    virtual ~Surface()
    {
        SDL_assert(_surface != nullptr);
        SDL_FreeSurface(_surface);
    };

    bool SetAlphaMod(Uint8 alpha)
    {
        SDL_assert(_surface != nullptr);
        return 0 == SDL_SetSurfaceAlphaMod(_surface, alpha);
    }

    bool SetBlendMode(SDL_BlendMode const& mode)
    {
        SDL_assert(_surface != nullptr);
        return 0 == SDL_SetSurfaceBlendMode(_surface, mode);
    }

    //    EnableColorKey(Uint32 r, Uint32 g, Uint32 b, Uint32 a)
    bool EnableColorKey(Uint8 r, Uint8 g, Uint8 b, Uint8 a)
    {
        SDL_assert(_surface != nullptr);
        Uint32 key = SDL_MapRGBA(_surface->format, r, g, b, a);
        return 0 == SDL_SetColorKey(_surface, SDL_TRUE, key);
    }

    bool BlitTo(SDL_Surface* dst_surface, SDL_Rect* src_rect, SDL_Rect* dst_rect)
    {
        SDL_assert(_surface != nullptr);
        return 0 == SDL_BlitSurface(_surface, src_rect, dst_surface, dst_rect);
    }

    explicit operator bool() const
    {
        return _surface != nullptr;
    }

    SDL_Surface* _surface;
};

//来自位图的表层
struct BitmapSurface : public Surface
{
    explicit BitmapSurface (char const* filename)
        : Surface(SDL_LoadBMP(filename))
    {

    }
};

}//sdl2

#endif // SDL_SURFACE_HPP_INCLUDED


//sdl_texture.hpp
#ifndef SDL_TEXTURE_HPP_INCLUDED
#define SDL_TEXTURE_HPP_INCLUDED

namespace sdl2
{

struct Texture
{
    Texture(SDL_Texture* texture)
        : _texture(texture)
    {

    }

    Texture(SDL_Renderer* renderer, SDL_Surface* surface)
        : _texture(SDL_CreateTextureFromSurface(renderer, surface))
    {

    }

    ~Texture()
    {
//        SDL_assert(_texture != nullptr);
        //_texture不一定就不空，所以需要修改
        if(_texture)
        SDL_DestroyTexture(_texture);
    }

    SDL_Texture* Release()
    {
        SDL_Texture* tmp;
        tmp = _texture;
//        *tmp = *_texture; //tmp和_texture已经指向同一数据了
        _texture = nullptr;
        return tmp;
    }

    explicit operator bool() const
    {
        return _texture != nullptr;
    }

    SDL_Texture* _texture;
};//Texture

}//sdl2

#endif // SDL_TEXTURE_HPP_INCLUDED


//sdl_window.hpp
#ifndef SDL_WINDOW_HPP_INCLUDED
#define SDL_WINDOW_HPP_INCLUDED

#include <SDL2/SDL.h>

namespace sdl2
{

struct WindowPosition
{
    WindowPosition()//默认构造
        : _x(SDL_WINDOWPOS_CENTERED), _y(SDL_WINDOWPOS_CENTERED)
    {

    }

    WindowPosition(int x, int y)//常规初始化
        : _x(x), _y(y)
    {

    }

    ~WindowPosition()
    {

    }

    WindowPosition& Centered(bool x_centered = true
                             , bool y_centered = true)
    {
        if(x_centered)
            _x = SDL_WINDOWPOS_CENTERED;
        if(y_centered)
            _y = SDL_WINDOWPOS_CENTERED;
    }

    int _x, _y;
};

struct WindowFlags
{
    //默认构造，用于构建一个没有指定任何特性的普通窗口
    WindowFlags()
        : _flags(0)
    {

    }

    ~WindowFlags()
    {

    }

    WindowFlags& FullScreenDesktop()
    {
        _flags &= ~SDL_WINDOW_FULLSCREEN;
        _flags |= SDL_WINDOW_FULLSCREEN_DESKTOP;
        return *this;
    }

    Uint32 _flags;
};

struct Window
{
    Window(char const* title
           , WindowPosition const& win_position
           , int x, int y
           , WindowFlags const& win_flags) //必须有const，否则无法引用右值()
    {
        _window = SDL_CreateWindow(title
                                   , win_position._x, win_position._y
                                   , x, y
                                   , win_flags._flags);
    }

    ~Window()
    {
        SDL_DestroyWindow(_window);
    }

    bool UpdateSurface()
    {
        SDL_assert(_window != nullptr);
        return 0 == SDL_UpdateWindowSurface(_window);
    }

    SDL_Surface* GetSurface()
    {
        SDL_assert(_window);
        return SDL_GetWindowSurface(_window);
    }

    explicit operator bool() const
    {
        return _window != nullptr;
    }

    Uint32 GetID()
    {
        SDL_assert(_window != nullptr);
        return SDL_GetWindowID(_window);
    }

    bool SetOpacity(float opacity)
    {
        SDL_assert(_window != nullptr);
        return 0 == SDL_SetWindowOpacity(_window, opacity);
    }

    void Hide()
    {
        SDL_assert(_window != nullptr);
        SDL_HideWindow(_window);
    }

    void Show()
    {
        SDL_assert(_window != nullptr);
        SDL_ShowWindow(_window);
    }

    SDL_Window* _window;
};

}//sdl2

#endif // SDL_WINDOW_HPP_INCLUDED

yanzhenxi
关注
  • 5
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
LINUX设备驱动第三版_588及代码.rar
08-26
LINUX设备驱动第三版_ 前言 第一章 设备驱动程序简介 设备驱动程序的作用 内核功能划分 设备和模块的分类 安全问题 版本编号 许可证条款 加入内核开发社团 本书概要 第二章 构造和运行模块 设置测试系统 Hello World模块 核心模块与应用程序的对比 编译和装载 内核符号表 预备知识 初始化和关闭 模块参数 在用户空间编写驱动程序 快速参考 第三章 字符设备驱动程序 scull的设计 主设备号和次设备号 一些重要的数据结构 字符设备的注册 open和release scull的内存使用 read和write 试试新设备 快速参考 第四章 调试技术 内核中的调试支持 通过打印调试 通过查询调试 通过监视调试 调试系统故障 调试器和相关工具 第五章 并发和竞态 scull的缺陷 并发及其管理 信号量和互斥体 completion 自旋锁 锁陷阱 除了锁之外的办法 快速参考 第六章 高级字符驱动程序操作 ioctl 阻塞型I/O poll和select 异步通知 定位设备 设备文件的访问控制 快速参考 第七章 时间、延迟及延缓操作 度量时间差 获取当前时间 延迟执行 内核定时器 tasklet 工作队列 快速参考 第八章 分配内存 kmalloc函数的内幕 后备高速缓存 get_free_page和相关函数 vmalloc及其辅助函数 per-CPU变量 获取大的缓冲区 快速参考 第九章 与硬件通信 I/O端口和I/O内存 使用I/O端口 I/O端口示例 使用I/O内存 快速参考 第十章 中断处理 准备并口 安装中断处理例程 实现中断处理例程 顶半部和底半部 中断共享 中断驱动的I/O 快速参考 第十一章 内核的数据类型 使用标准C语言类型 为数据项分配确定的空间大小 接口特定的类型 其他有关移植性的问题 链表 快速参考 第十二章 PCI驱动程序 PCI接口 ISA回顾 PC/104和PC/104+ 其他的PC总线 SBus NuBus 外部总线 快速参考 第十三章 USB驱动程序 USB设备基础 USB和Sysfs USB urb 编写USB驱动程序 不使用urb的USB传输 快速参考 第十四章 Linux设备模型 kobject、kset和子系统 低层sysfs操作 热插拔事件的产生 总线、设备和驱动程序 类 各环节的整合 热插拔 处理固件 快速索引 第十五章 内存映射和DMA Linux的内存管理 mmap设备操作 执行直接I/O访问 直接内存访问 快速参考 第十六章 块设备驱动程序 注册 块设备操作 请求处理 其他一些细节 快速参考 第十七章 网络驱动程序 snull设计 连接到内核 net_device结构细节 打开和关闭 数据包传输 数据包的接收 中断处理例程 不使用接收中断 链路状态的改变 套接字缓冲区 MAC 地址解析 定制 ioctl 命令 统计信息 组播 其他知识点详解 快速参考 第十八章 TTY驱动程序 小型TTY驱动程序 tty_driver函数指针 TTY线路设置 ioctls proc和sysfs对TTY设备的处理 tty_driver结构详解 tty_operations结构详解 tty_struct结构详解 快速参考 参考书目 9112405-1_o.jpg (85.53 KB, 下载次数: 50)
翻页分页css代码 CSS翻页代.rar_css_page_sweeti4m_翻页分页css代码 CSS翻页代
09-24
经典24款Page翻页分页css代码 CSS翻页代码
VolCast:使用“假”3D 纹理通过光线投射完成基于 WebGL 的体积渲染。 这将是一个仅存在于浏览器中的体积渲染器，因此请查看 gh-page 以获取代码
06-07
广播 使用“假”3D 纹理通过光线投射完成基于 WebGL 的体积渲染。 这将是一个仅驻留在浏览器中的体积渲染器，因此请查看 gh-page 以获取代码。 构建过程 首先，安装全局包。 我们依靠 bower 来处理前端包，依靠 gulp 来处理构建过程。 npm install -g bower npm install -g gulp 然后我们需要使用 npm 和 bower 安装本地包。 npm intall bower install 要构建，只需运行 gulp 构建成功后，dist目录下的内容就是最终的网站。 部署 由于我们的体积渲染器是严格的前端，我们使用 github pages 托管它，所以分支 gh-pages 是部署分支。 要部署，只需将 dist 目录中的内容上传到 gh-pages。
react-page-swapper:简化页面转换实现的协调器
07-24
React页面交换器 一种简化页面转换实现的协调器。 安装 $ npm install @moxy/react-page-swapper 这个库是用现代 JavaScript 编写的，并以 CommonJS 和 ES 模块转译变体发布。 如果您针对较旧的浏览器，请确保相应地进行转译。 动机 乍一看，向您的网站添加页面转换看起来很容易。 网络上有大量文章建议使用诸如<TransitionGroup>或<AnimatePresence>，将页面过渡添加到您的网站。 然而，它们是通用的解决方案，因此，它们错过了页面转换的重要步骤。 其中，他们错过的最重要的步骤之一是滚动位置。 无论滚动位于顶部还是底部，您都希望页面过渡效果很好。 那么，什么才是好的页面转换库呢？ 以下是交换页面时要采取的基本步骤： 从文档的正常流程中删除当前页面，同时将其保持在相同的位置和相同的尺寸。 这通常涉及使其p
游戏引擎剖析
大海的专栏
09-04 1956
原文作者：Jake Simpson 译者： 向海 Email：GameWorldChina@myway.com  第1部分: 游戏引擎介绍， 渲染和构造3D世界 介绍 　　自Doom游戏时代以来我们已经走了很远。 DOOM不只是一款伟大的游戏，它同时也开创了一种新的游戏编程模式: 游戏 "引擎"。 这种模块化，可伸缩和扩展的设计观念可以让游戏玩家和程序设计者深入到游戏核心，用新的模型，场景和声音创
PageOffice_4.5 Java版本，带服务端、客户端示例代码、签章系统
04-24
javaWeb开发，word文档在浏览器中在线打开！PageOffice，从官网下载PageOffice for Java。压缩包文件，示例代码等所有内容。
C++中的智能指针类别
GOLOJO的博客
05-31 918
C++中的智能指针是用来管理动态内存的对象，避免我们手动管理内存时可能会带来的复杂性和错误。C++标准库提供了几种不同类型的智能指针，包括``、``和`- 优先使用``和``来创建智能指针，避免手动使用`new`，可以提高代码的安全性和性能。- 在使用``时要特别小心循环引用的问题。可以使用``来打破循环引用。- 确保智能指针的生命周期管理正确，避免悬空指针和内存泄漏。- 虽然智能指针极大地简化了内存管理，但也带来了额外的开销，如引用计数的维护。因此，在性能敏感的代码中，应慎重使用`
C语言 指针——指针变量的定义、初始化及解引用
hangweijie的博客
05-29 1256
目录指针内存如何编址？如何对变量进行寻址？用什么类型的变量来存放变量的地址?如何显示变量的地址?​编辑使用未初始化的指针会怎样？NULL是什么？如何访问指针变量指向的存储单元中的数据？指针变量的定义和初始化
C++中的左值和右值
最新发布
weixin_47987343的博客
06-04 94
左值通常与变量和持久数据关联。右值通常与临时数据和表达式的结果关联。右值引用提供了一种操作右值并优化资源管理和性能的方式。
无向图中两点(x1,y1)(x2,y2)是否连通(bfs&并查集)两种方法解决(c++)
weixin_73886306的博客
05-30 413
无向图中两点(x1,y1)(x2,y2)是否连通(bfs&并查集)两种方法解决(c++)
C++ 多重继承的内存布局和指针偏移
Damon_X的博客
05-30 317
在 C++ 程序里，在有多重继承的类里面。偏移的大小，等于派生类的继承顺序表里面，排在该类前面的所有的类的数据成员（含虚表指针）所占的空间大小总和。注意：在 D 的继承关系链里面，只有基类 B 有虚函数，因此对于 D 对象而言，总体只有一个虚表指针，也就是（B）基类对象中的虚表指针。D 继承自A, B, C，它的大小等于 A, B, C 的所有数据成员的大小，加上其自身的数据成员和虚表指针的总的大小：4(b) + 4(c) + 4(d) + 8(vptr) = 20 字节。我们首先来分析这四个类的大小。
C++的MQTT开发：使用Paho的C++接口实现消息发布、订阅、连接RabbitMQ
_XLinC_的专栏
06-02 777
具体的MQTT应用程序可能会有不同的需求和限制。如果应用程序需要在发送消息之间有较长的时间间隔，或者需要处理长时间的非活动状态，那么可以考虑在一段时间后断开连接，并在需要时重新连接。您可以参考paho的官方文档和示例代码来进一步了解和掌握paho的cpp接口的使用。本示例代码仅提供了一个基本的框架，需要根据自己的需求进行更多的自定义和错误处理。是异步的客户端实现，它使用了异步操作和回调函数来处理发送和接收消息，不会阻塞当前线程。提供了更强大的功能和更好的并发性能，但它需要更多的代码和处理异步回调函数。
【C++】问题及补充（2）
2301_80207207的博客
05-30 889
vector和list都是C++ STL中的容器，它们被定义在不同的头文件中。vector在中定义，而list在中定义。因此，如果要使用它们，需要包含相应的头文件。通常情况下，C++中的类定义需要包含在头文件中，而类的实现则包含在源文件中。这样做的目的是为了避免在多个源文件中重复定义同一个类，从而引发编译错误。因此，在C++ STL中，vector和list的定义也需要写在头文件中，以便在需要使用它们的源文件中包含相应的头文件即可。
[C++]vector的模拟实现
SUICIDEKILL的博客
06-01 1035
容器：向量（vector）vector是表示大小可以变化的数组的序列容器。像数组一样，向量对其元素使用连续的存储位置，这意味着也可以使用指向其元素的常规指针上的偏移量来访问其元素，并且与数组中的元素一样高效。但与数组不同的是，它们的大小可以动态变化，它们的存储由容器自动处理。模板类操作一、构造函数vector();默认构造用n个val进行填充初始化防止vector(int,int)与下面的模板函数发生歧义迭代器区间初始化用初始化列表进行初始化拷贝构造函数赋值构造。
Linux C语言：运算符（上）
Liu1013216383的博客
06-04 481
将变量的值进行加1和减1的操作；自增和自减运算符都是一元运算符，只需要一个操作数；l可以作为前置运算符，也可以作为后置运算符前置： 运算符位于变量之前 ++i --i后置：运算符位于变量之后 i++ i-- 如果前置或后置作为一个单独的语句出现，并没有什么区别。
JZ36 二叉搜索树与双向链表（C++）
lim6ere的博客
05-30 353
在本篇文章中，我们将会讲解牛客网上一道二叉树经典题目JZ36 二叉搜索树与双向链表，我们用C++来对代码进行编写。以上就是今天要讲的内容，本文仅仅详细介绍JZ36 二叉搜索树与双向链表这道题目。希望对大家的学习有所帮助，仅供参考 如有错误请大佬指点我会尽快去改正 欢迎大家来评论~~ 😘 😘 😘。
Android AAudio——C API控制音频流（四）
小旭的专栏
06-04 360
下图是状态变化流程图，虚线框表示瞬时状态，实线框表示稳定状态。
【第七节】C++的STL基本使用
攻城狮7号的博客
05-30 1054
长期以来，软件行业一直致力于打造一种可重复利用的资源以及相应的构建方法，旨在确保程序员的心血不因时间的流逝或人员的变动而付诸东流。从简单的函数、类别，到复杂的函数库、类别库以及各种组件，再到模块化设计和面向对象的编程范式，这一切努力均是为了提高代码复用性。然而，复用性的实现必须依托于一套明确的标准。令人遗憾的是，在许多软件开发环境中，即便是最基础的数据结构和算法，也未能形成统一的标准。这导致大量程序员不得不重复进行许多前人已经完成的工作，仅仅是因为他们手中没有现成的、可复用的程序代码。
如何选择实名认证接口？C++身份证二、三要素实名认证接口提供厂商
weixin_49544544的博客
06-04 59
线上平台进行身份证实名认证，有助于保障交易的安全性，防止身份信息被盗用的风险，其主要应用于金融、在线银行、支付平台、社交媒体、账号注册、内容发布等多种应用场景。身份证识别接口即可快速、精准的识别身份证上的文字信息，翔云身份证实名认证接口，通过提取到的身份证信息进行真伪的实时认证。除身份证实名认证接口外，翔云平台还提供了手机号实名认证、银行卡实名认证等多种认证解决方案供有需要的企业进行选择！翔云人工智能开放平台专注于API接口的提供，为有需要的企业提供了便捷、高效的身份证识别+用户仅需上传身份证图片，
jsp动态渲染页面方法代码
03-08
以下是一个简单的 JSP 动态渲染页面的示例代码： ``` <%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%> <!DOCTYPE html> 动态渲染页面示例 欢迎来到我的网站！ ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值