小编Cof*_*ode的帖子

std::observer_ptr库基础技术规范V2 中的构造究竟有什么意义？

在我看来,它所做的一切都是裸露的T*,如果不增加动态内存安全性,这似乎是一个多余的步骤.

在我的所有代码中,我使用std::unique_ptr了我需要明确拥有对象的位置以及std::shared_ptr可以共享对象所有权的位置.

这非常有效并且可以防止意外解除引用已经被破坏的对象.

std::observer_ptr 当然,不保证观察到的物体的寿命.

如果它是从a构造的,std::unique_ptr或者std::shared_ptr我会看到在这样的结构中使用,但任何简单使用的代码T*可能只是继续这样做,如果他们计划移动到任何它将是std::shared_ptr和/或std::unique_ptr(取决于在使用上).

给出一个简单的示例函数:

template<typename T>
auto func(std::observer_ptr<T> ptr){}

如果停止智能指针在观察它们时销毁它们存储的对象将会有用.

但如果我想观察std::shared_ptr或std::unique_ptr我必须写:

auto main() -> int{
    auto uptr = std::make_unique<int>(5);
    auto sptr = std::make_shared<int>(6);
    func(uptr.get());
    func(sptr.get());
}

这使得它不比以下更安全:

template<typename T>
auto func(T *ptr){}

那么,这个新结构的用途是什么？

它只是用于自我记录的来源吗？

我只是测试查看一些代码并注意到类似于:

template<typename T>
class example{
    public:
        example(T t): m_value{t}{}

        const T &value = m_value;

    private:
        T m_value;
};

我以前没见过这个.几乎我以前使用的每个API或库都定义了一个返回成员变量的函数,而不是对它的常量引用:

template<typename T>
class example{
    public:
        example(T t): m_value{t}{}

        const T &value() const{
            return m_value;
        }

    private:
        T m_value;
};

为什么第一种方式不常见？有什么缺点？

鉴于我们使用OpenGL 4.5或支持GL_ARB_direct_state_access扩展,我们有新功能glCreateBuffers.

此函数具有相同的签名glGenBuffers,但指定:

返回n先前未使用的缓冲区名称buffers,每个缓冲区名称表示初始化的新缓冲区对象,就好像它已绑定到未指定的目标一样

glGenBuffers 有以下规格:

调用返回的缓冲区对象名称glGenBuffers不会被后续调用返回,除非它们首先被删除glDeleteBuffers.

因此,返回的任何缓冲区名称glCreateBuffers将永远不会再次使用,但可以使用glGenBuffers.

似乎glCreateBuffers总会创建新的缓冲区对象并返回它们的名称,并且glGenBuffers只有在之前没有删除过的缓冲区时才会创建新的缓冲区.

添加此功能有什么优势？

我什么时候应该glCreateBuffers用完glGenBuffers？

PS
我认为这代表所有glCreate*添加的功能GL_ARB_direct_state_access

是否有一些标准库函数/类这个lambda表达式的行为:

void some_func(int some_arg, float some_other_arg){
    static int do_once = ([](){
        // will be run once upon first function call but never again
        return 0; // dummy return value
    })();
    // will always run
}

写这个就像是一个黑客,但我想不出另外做这个的方式,而不仅仅是调用函数main,但我实际上做的事情取决于模板参数,我需要保持它像通用一样可能.

对于上下文:
我atexit为每个不同的模板参数注册一个函数,但只注册一次:第一次调用它.

我期待一个连续容器上的std :: fill,比如说std :: vector,会自动编译成memset的调用.但是,当我尝试以下代码时

#include <vector>
#include <algorithm>
#include <numeric>

using namespace std;

int main()
{
    vector<double> vec(300000);

    fill(vec.begin(),vec.end(),0.0);

    memset(&vec[0],0,vec.size()*sizeof(double));
}

gcc将第一个std :: fill编译成一个简单的循环.但我认为可以通过SSE或其他高级矢量化代码来完成.请给我一个提示.谢谢.

如"可能的实现"所示,std::apply我们看到标准库函数std::invoke用于调用可调用对象F.

这种情况需要吗？如果是这样,出于什么原因？

写作有什么好处:

template<typename F, typename ... Args>
decltype(auto) func(F &&f, Args &&... args){
    return std::invoke(std::forward<F>(f), std::forward<Args>(args)...);
}

过度:

template<typename F, typename ... Args>
decltype(auto) func(F &&f, Args &&... args){
    return std::forward<F>(f)(std::forward<Args>(args)...);
}

？

我正在尝试使用xcb进行输入时如何忽略重复键.

我需要这样的事情:

uint32_t mask = XCB_KB_AUTO_REPEAT_MODE;
uint32_t values[] = {XCB_AUTO_REPEAT_MODE_OFF, None};

xcb_change_keyboard_control(xcb_connection, mask, values);

但不影响整个系统.

我在X11应用程序中读过忽略自动重复,但我无法将其转换为xcb.也就是说,我找不到相当于的xcb XEventsQueued.

我该怎么做呢？

说我有这样一堂课:

enum class Flags : char
{
    FLAG_1 = 1;
    FLAG_2 = 2;
    FLAG_3 = 4;
    FLAG_4 = 8;
};

现在,我可以拥有一个具有类型标志的变量并为其分配值7吗？我可以这样做:

Flags f = Flags::FLAG_1 | Flags::FLAG_2 | Flags::FLAG_3;

要么

Flags f = 7;

出现这个问题是因为在枚举中我没有定义价值7.

在将当前的延迟渲染器更改为使用对数深度缓冲区后,我无法解决,对于我的生活,如何从深度缓冲区值重建世界空间深度.

当我编写OpenGL默认z/w深度时,我可以通过从窗口空间转换到NDC空间来轻松计算此值,然后执行逆透视变换.

我在第二遍片段着色器中完成了所有这些操作:

uniform sampler2D depth_tex;

uniform mat4 inv_view_proj_mat;

in vec2 uv_f;

vec3 reconstruct_pos(){
    float z = texture(depth_tex, uv_f).r;
    vec4 pos = vec4(uv_f, z, 1.0) * 2.0 - 1.0;
    pos = inv_view_proj_mat * pos;

    return pos.xyz / pos.w;
}

并得到一个看起来非常正确的结果:

但现在通往简单z价值的道路并不那么容易(似乎也不应该这么难).

我的第一次传递的顶点着色器具有日志深度:

#version 330 core
#extension GL_ARB_shading_language_420pack : require

layout(location = 0) in vec3 pos;
layout(location = 1) in vec2 uv;

uniform mat4 mvp_mat;

uniform float FC;

out vec2 uv_f;
out float logz_f;
out float FC_2_f; …

我有一个vec_base像这样定义的类:

template<typename T, std::size_t Size>
class vec_base;

我想把它专门化

vec_base<float, /* any multiple of 4 */>

和

vec_base<double, /* any multiple of 2 */>

例如,可以独立地拥有特定成员

vec_base<int, 6>

哪个会有我已定义的通用成员

我很难实现这个,因为允许的宽松大小(4或2的任意倍数),如果它特别是2或4我知道我可以执行完全专业化,但事实并非如此:/

我该怎么做？感谢任何帮助,我总是喜欢学习新的语言技巧!

编辑

好吧所以我到目前为止:

template<std::size_t Size>
struct is_div_by_4{static const bool value = (Size % 4 == 0);};
// have to define because of template requirements
// about not being dependent on other parameters

template<typename T, std::size_t Size, bool is_special>
class vec_base;

template<typename T, std::size_t Size>
class vec_base<T, Size, false>{
    // generic …