小编orl*_*rlp的帖子

我创建了一个俄罗斯方块游戏,你可以在比赛结束后重新开始.我用goto实现了这个快速和脏(见代码).这个Game类依赖于析构函数,这些是用这些goto调用的吗？这个goto有多糟糕,可以接受,或者我该怎么做？

int APIENTRY WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow) {
    // initiate sdl
    sdl_init();

    // seed rng
    srand(time(NULL));

    newgame: // new game label
    Game game(GAME_WIDTH, GAME_HEIGHT, 1, screen);

    // keydowns
    bool fastfall = false;
    bool gamerunning = true;
    Uint32 lastupdate = 0;

    while (gamerunning && game.isalive()) {
        // game running stuff here
    }

    // game over stuff here

    while (gamerunning) {
        if (SDL_PollEvent(&event)) {
            if (event.type == SDL_QUIT) {
                gamerunning = false;
            } else if (event.type …

一张图片说千言万语,那两个呢？我有这个地图艺术:

为了将其实际用作地图,我将此纹理缩放6次.然而,这并没有像预期的那样:

所有OpenGL代码都在我的自制2D OpenGL渲染库中,由于OpenGL是状态机,因此很难实际记录整个渲染过程.但这里是+/-我做的(代码是Python):

width, height = window.get_size()
glViewport(0, 0, width, height)

glMatrixMode(GL_PROJECTION)
glPushMatrix()
glLoadIdentity()

glOrtho(0.0, width, height, 0.0, 0.0, 1.0)

glMatrixMode(GL_MODELVIEW)
glPushMatrix()
glLoadIdentity()

# displacement trick for exact pixelization
glTranslatef(0.375, 0.375, 0.0)

glDisable(GL_DEPTH_TEST)
glEnable(GL_BLEND)
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA)

glEnable(self.texture.target) # GL_TEXTURE_2D
glBindTexture(self.texture.target, self.texture.id)

glTexParameteri(self.texture.target, GL_TEXTURE_MIN_FILTER, GL_NEAREST)
glTexParameteri(self.texture.target, GL_TEXTURE_MAG_FILTER, GL_NEAREST)

glPushMatrix()

glTranslatef(self.x, self.y, 0.0) # self.x and self.y are negative int offsets
glScalef(self.scale_x, self.scale_y, 1.0) # scale_x and scale_y are both 6

glBegin(GL_QUADS)
glTexCoord2i(0, 0)
glVertex2i(0, 0)
glTexCoord2i(0, 1)
glVertex2i(0, self.texture.height)
glTexCoord2i(1, …

比方说,我有两个对象i和f相应的类型I和F.我知道这std::is_integral<I>::value是真的,而且std::is_floating_point<F>::value是真的.

是否有完全符合标准的方法来确定值i是否小于f？的值？请注意强调"完全符合标准",对于这个问题,我只对那些由C++标准保证支持的答案感兴趣.

琐碎的实现i < I(f)不起作用,因为它的值f可能不适合i.平凡的实现F(i) < f也不起作用,因为精度f可能不足以表示i,导致i四舍五入到等于f(如果你有IEEE754浮点数,16777219 < 16777220.f失败)的值.

但是这里出现了真正的困境:如果你想用来std::numeric_limits::max缓解这些问题,你可以回到比较浮点数和整数的原始问题!这是因为类型std::numeric_limits::max等于原始类型.

假设我有两种算术类型,一个整数I,一个浮点数,F.我还假设std::numeric_limits<I>::max()小于std::numeric_limits<F>::max().

现在,假设我有一个正整数值i.因为可表示的范围F大于I,F(i)应始终定义行为.

但是,如果我有一个浮点值f,那么f == F(i),是否I(f)定义明确？换句话说,I(F(i))总是定义行为？

C++ 14标准的相关部分:

4.9浮动积分转换 [conv.fpint]

1. 可以将浮点类型的prvalue转换为整数类型的prvalue.转换截断; 也就是说,丢弃小数部分.如果截断的值无法在目标类型中表示,则行为未定义.[ 注意:如果目的地类型是bool,请参见4.12.- 结束说明 ]
2. 可以将整数类型或无范围枚举类型的prvalue转换为浮点类型的prvalue.如果可能,结果是准确的.如果要转换的值在可以表示的值范围内,但该值无法准确表示,则它是实现定义的下一个较低或较高可表示值的选择.[ 注意:如果积分值不能完全表示为浮动类型的值,则会发生精度损失.- 结束注释 ]如果转换的值超出了可以表示的值范围,则行为未定义.如果源类型为bool,则将值 false转换为零,并将值true转换为1.

我读的boost::asio::ip::udp::socket是这样的:

using boost::asio::ip::udp;

// ...

char recv_buf[128];
udp::endpoint sender_endpoint;
size_t len = socket.receive_from(boost::asio::buffer(recv_buf), sender_endpoint);

现在,这完全正常,但我能够接收到的最大字符数现在是127.但是我遇到了一个问题,因为我需要接受一些数据输入,其长度可以大大改变(并且不是很好 - 带有前缀标题的定义长度,例如).对此的解决方案是动态扩展缓冲区,如向量.是否有可能创建一个动态扩展boost::asio::buffer以接受(理论上)infite量的输入并将其存储在容器中？

在此上下文中T是某种类型,并且allocator是该类型的分配器对象.默认情况下,std::allocator<T>但这不一定是真的.

我有一大堆记忆allocator.allocate(n).我也有一个容器con中T的对象(比如,一个std::vector<T>).我想用T对象初始化那块内存.

存储块的位置存储在T* data.

这两个代码示例是否始终相同？

#include <memory>

// example 1
std::uninitialized_copy(con.begin(), con.end(), data)

// example 2
std::vector<T>::const_iterator in = con.begin();
for (T* out = data; in != con.end(); ++out, ++in) {
    allocator.construct(out, *in);
}

对于这两个？

#include <memory>

T val = T(); // could be any T value

// example 3
std::uninitialized_fill(data, data + n, val)

// example 4
for (T* out = …

我有一个python 2.7的Python脚本,这样说:

print("Hello World!")

接下来我将其转换为C使用:

python cython.py --embed helloworld.py

然后我尝试静态编译它:

gcc -IC:\Python27\include -LC:\Python27\libs helloworld.c -Wl,-Bstatic -lpython27
  -Wl,-Bdynamic

但是gcc只是创建了一个使用python27.dll运行时的二进制文件.如何创建静态链接到运行时的二进制文件？

这是我的文件结构:

[mylibrary]
    __init__.py 

    [codecs]
        __init__.py < this is the file that we're talking about
        optional.py

现在我在标记的代码中有这个代码__init__.py:

def load_optional_codecs():
    try:
        from mylibrary.codecs import optional
        # do stuff with optional
    except ImportError:
        pass

这有一个问题.如果optional模块本身包含导入异常,它将无声地失败.有没有办法导入可选模块而不会从模块中消除任何异常？

这可能看起来像一个模糊的场景,但由于沉默的异常我得到了一个令人讨厌的错误,我想防止将来发生这种情况.

通过C规范阅读我发现了这个功能:

double remquo(double x, double y, int *quo);
float remquof(float x, float y, int *quo);
long double remquol(long double x, long double y,
    int *quo);

该remquo函数计算剩余相同的remainder功能.在由quo指向的对象中,它们存储一个值,其符号是符号,x/y并且其大小是等于2 ^ n 的整数商的大小的模数x/y,其中 n是大于或等于3的实现定义的整数.

该remquo函数返回xREM y.如果y为零,则存储在指向的对象中的值quo未指定,并且是否发生域错误或函数返回零是实现定义的.

我理解它返回什么,它返回fmod(x, y),但我不明白整个quo部分.它在语义上是否与此相同？

*quo = (int) x/y;
*quo %= n; /* n implementation defined */

我的最后一个问题是,这个功能有用吗？

说我有以下示例:

#include <cstdlib>

class A {
public:
    static const std::size_t value = 42;
};

简而言之,我有一个类(或者更好,想要)一个带有值A的static const std::size_t成员(在编译时确定).value42

现在,IIRC,这在某些情况下才能正常工作.例如,当你拿地址时,它不会A::value.为了使其在所有情况下都能正常工作,您需要在某个实现文件中添加定义:

const std::size_t A::value;

但是,我不能这样做,因为我希望这个文件只是标题.另一种常见的解决方案是:

class A {
public:
    enum { value = 42 };
};

我不喜欢这样的解决方案,因为我想要的类型A::value是std::size_t.

什么是这个问题的好方法？最好是一个小巧便携的解决方案,而不是具有巨大宏观魔力的东西BOOST_STATIC_CONSTANT.

我想要一个C++ 03的解决方案,而不是C++ 11(那里很简单).