小编jah*_*aho的帖子

我正在尝试使用智能指针在我的类中保存 COM 对象，同时避免 ComPtr。是否可以为此目的使用 unique_ptr ？

我对智能指针很陌生，到目前为止我有点困惑。请考虑以下简化代码：

class Texture
{
private:
    struct ComDeleter
    {
        operator() (IUnknown* p)
        {
            p.Release();
            delete p;
        }
    }

    ID3D11Texture* m_dumbTexture;
    std::unique_ptr<ID3D11Texture, ComDeleter> m_smartTexture;

public:
    ID3D11Texture* getDumbTexture() const { return m_dumbTexture; }
    ID3D11Texture* getSmartTexture() const { return m_smartTexture.get(); } // what to return here?
}

Texture::Texture() :
    dumbTexture  (NULL),
    smartTexture (nullptr)
{
}

Texture::init()
{
    D3DX11CreateTexture(&m_dumbTexture);
    D3DX11CreateTexture(&m_smartTexture.get());  // error: '&' requires r-value
}

所以我的问题是：getter 应该返回什么（原始指针或 unique_ptr 实例）以及如何将 unique_ptr 传递给创建资源的函数？

我有两个相关的问题,一个是普通的,一个是我正在研究的项目.

1. 通常,如果我有一个循环有很多迭代(数百万),某些代码部分在某些条件下执行,那么一个循环有多个条件语句或多个循环没有它们会更好(更有效).例如.

例1:

while (something())
{
    // some common code
    if (condition_a)
        // some code
    if (condition_b)
        // some code
    // some more common code
}

例2:

if (condition_a && condition_b)
{
    while (something())
    {
        // some common and specific code
    }
}
else if (condition_a)
    while (something()) //..
else if (condition_b)
    // Another loop
else //...

似乎示例2将以冗余为代价导致更高效的代码,因为条件仅被检查一次而不是数百万次.如果公共代码很大或者有很多可能的条件,那么这似乎是多余的.

1. 现在来看我的具体问题.我有一个函数,它从文件中读取点并将它们插入到数据结构中.它看起来像这样:

   while(reader-> read_point){//做一些事//插入点}

问题在于,有几个函数用于读取应根据用户提供的标准使用的点.例如read_point_inside_circle(),read_point_inside_rectangle()等.

理想情况下,我想使用函数指针事先决定正确的函数,但我不认为这是可能的,因为reader是Reader类的一个实例(如果有可能以某种方式解决我的所有问题).

在这种情况下,如果我有多个循环只有条件不同,或者我应该使用多个if语句以避免冗余代码,那就更好了,例如.

for(;;)
{
    if (read_every_point)
        if(!reader->read_point())
            break;
    else if (read_inside_circle)
        if(!reader->read_inside_circle())
            break;
    else if // ...
}

我正在浏览所有Rastertek DirectX 教程，这些教程非常好，作者倾向于使用多个着色器来处理不同的事情。在后来的一个教程中，他甚至介绍了一个着色器管理器类。

虽然我认为使用具有多种技术的单个着色器会更有效，但基于其他一些来源。教程中的多个着色器是为了简单起见，还是在某些情况下使用多个着色器比使用单个大着色器更好？

我正在尝试向我的应用程序添加凹凸贴图功能，但我得到了非常多面的模型：

发生这种情况的原因是因为我正在计算每个面的切线、副法线和法线，而完全忽略了我从模型文件中获得的法线。

计算目前使用三角形的两条边和纹理空间向量得到切线和副法线，然后通过叉积计算法线。模型加载后，这一切都在 CPU 上完成，然后将值存储为模型几何的一部分。

    vector1 = vertex2.coords - vertex1.coords;      
    vector2 = vertex3.coords - vertex1.coords;

    tuVector = vertex2.texcoords - vertex1.texcoords;
    tvVector = vertex3.texcoords - vertex1.texcoords;

    float den = 1.0f / (tuVector.x * tvVector.y - tuVector.y * tvVector.x);

    tangent.x = (tvVector.y * vector1.x - tvVector.x * vector2.x) * den;
    tangent.y = (tvVector.y * vector1.y - tvVector.x * vector2.y) * den;
    tangent.z = (tvVector.y * vector1.z - tvVector.x * vector2.z) * den;

    binormal.x = (tuVector.x * vector2.x - tuVector.y * vector1.x) * …

我正在浏览有关 DirectX 的所有 MS 教程，我注意到它们总是将世界、视图和投影矩阵传递给该技术，然后在顶点着色器中将它们相乘。

是否有理由这样做而不是在绘制之前将矩阵相乘，然后将单个 WVP 矩阵传递给着色器？这样矩阵将每帧相乘一次而不是每个顶点一次，对吗？

提前致谢。

编辑：更新了示例代码

MS教程：

matrix World;
matrix View;
matrix Projection;

struct VS_INPUT
{
    float4 Pos : POSITION;
    float4 Color : COLOR;
};

struct VS_OUTPUT
{
    float4 Pos : SV_POSITION;
    float4 Color : COLOR;
};

PS_INPUT VS( VS_INPUT input )
{
    VS_OUTPUT output;
    output.Pos = mul( input.Pos, World );
    output.Pos = mul( output.Pos, View );
    output.Pos = mul( output.Pos, Projection );
    output.Color = input.Color;

    return output;
}

为什么不这样：

matrix WVP;

struct VS_INPUT
{
    float4 …

我有两个名为file_utils.h和file_utils.cpp的文件,它们包含一些由不同类使用的方法和变量.以下是它的外观示例:

file_utils.h:

namespace my_namespace
{
extern Foo* foo;
extern Bar* bar;

void my_function(Blah* blah);
}

file_utils.cpp

#include "file_utils.h"

void my_namespace::my_function(Blah* blah)
{
    foo = 0;    // undefined reference to my_namespace::foo
    bar = 0;    // undefined reference to my_namespace::bar
    //...
}

some_class.cpp

#include "file_utils.h"

some_function()
{
    my_namespace::my_function(blah);
    this->foo = *my_namespace::foo; // will that work ok?
}

所以错误在评论中.如果我删除extern关键字,我会收到multiple definition of my_namespace::foo错误.问题是什么？从设计的角度来看,这是一个好主意,还是应该尝试使用静态成员和方法的类？

因此,我一直在进行关于编码的测试,并且对"Max Counters"(位于https://codility.com/demo/take-sample-test/max_counters)感到困惑.我的第一个显而易见的解决方案是:

def solution(N, A):

    counters = N * [0];    

    for a in A:
        if 1 <= a <= N:
            counters[a - 1] += 1;
        elif a == N + 1:
            counters = N * [max(counters)];

    return counters

由于每次调用max计数器填充整个数组,因此工作得很好,但需要花费太多时间.

所以我提出了以下解决方案,似乎适用于小输入,但随机提供中等和大的不正确的结果.

def solution(N, A):

    counters = N * [0];
    current_max = 0;
    last_update = 0;

    for a in A:
        if 1 <= a <= N:
            counters[a - 1] += 1;

            if counters[a - 1] < last_update:
                counters[a - 1] …

可能重复:
C++中枚举类型数据的大小是多少？

如何在内部存储枚举数据类型(我想象为8/16/32位int？)并且可以安全地序列化,还是应该使用像quint8这样的值来存储值？换句话说,sizeof(MyEnum)在所有平台上保证大小相同？

我正在尝试用C++编写一些多线程代码,但我似乎无处可去.我做了一些研究,但我很难找到一些基本的例子来告诉我如何实现我的需要.我正在使用Linux中的Gtk应用程序,每次都有耗时的操作,比如加载文件,GUI锁定(如果我尝试移动它,所有控件等都会消失,只留下空白窗口).这显然可以通过线程解决,但我不知道从哪里开始寻找.我应该使用pthreads,C++ Thread,boost :: Thread,Glib :: Thread吗？使用上述任何一项的区别和原因是什么？

我的目标是建立一个消息对话框,甚至是一个进度条对话框,可以显示何时在后台运行操作.基本上任何会在完成工作时让GUI响应的东西.我真的很感谢一些示例或链接到一些要学习的源代码.

以下两个示例之间是否有任何区别,应该优先于其他两个示例:

例1:

class A
{
    int i;
    B* b;

    do_something();
    do_something_else();
}

A::do_something()
{    
    do_something_else();
}

例2:

class A
{
    int i;

    do_something()
    do_something_else(B* b)
}

A::do_something()
{
    B* b;
    do_something_else(b);
}

现在让我们说使用几种方法b是否更好地将它们作为参数或不带参数并使用成员变量？两种方法之间的性能有差异吗？我可以看到两者的好处,但哪一个更受青睐？

我有一个带有parse(int argc, char* argv[])函数的类,我必须使用它来设置对象的所需状态.我正在使用gui中的参数stringstream,然后我试图将它们转换为char**以将它们传递给函数.这是我得到的:

std::stringstream sstream;

sstream << "-clip" << " " << min_x_entry.get_text()
        << " " << max_x_entry.get_text(); // etc.

std::cout << sstream.str();    // All looks good here

std::vector<std::string> args;
std::vector<char*> argv;
std::string arg;

while (sstream >> arg)
{
    args.push_back(arg);
    argv.push_back(const_cast<char*>(args.back().c_str()));
}
argv.push_back(0);

int argc = args.size();

for (int i = 0; i < argc; ++i)
    std::cout << &argv[0][i];    // This outputs garbage

my_object.parse(argc, &argv[0])  // And this fails

我错过了什么？有没有更好的方法来实现这一目标？