小编Gri*_*art的帖子

我读了一些关于使用SSE内在函数的内容,并尝试了用双精度实现四元数旋转的运气.以下是我写的正常和SSE函数,

void quat_rot(quat_t a, REAL* restrict b){
    ///////////////////////////////////////////
    // Multiply vector b by quaternion a     //
    ///////////////////////////////////////////
    REAL cross_temp[3],result[3];

    cross_temp[0]=a.el[2]*b[2]-a.el[3]*b[1]+a.el[0]*b[0];
    cross_temp[1]=a.el[3]*b[0]-a.el[1]*b[2]+a.el[0]*b[1];
    cross_temp[2]=a.el[1]*b[1]-a.el[2]*b[0]+a.el[0]*b[2];

    result[0]=b[0]+2.0*(a.el[2]*cross_temp[2]-a.el[3]*cross_temp[1]);
    result[1]=b[1]+2.0*(a.el[3]*cross_temp[0]-a.el[1]*cross_temp[2]);
    result[2]=b[2]+2.0*(a.el[1]*cross_temp[1]-a.el[2]*cross_temp[0]);

    b[0]=result[0];
    b[1]=result[1];
    b[2]=result[2];
}

有了SSE

inline void cross_p(__m128d *a, __m128d *b, __m128d *c){
    const __m128d SIGN_NP = _mm_set_pd(0.0, -0.0);


    __m128d l1 = _mm_mul_pd( _mm_unpacklo_pd(a[1], a[1]), b[0] );

    __m128d l2 = _mm_mul_pd( _mm_unpacklo_pd(b[1], b[1]), a[0] );
    __m128d m1 = _mm_sub_pd(l1, l2);
            m1 = _mm_shuffle_pd(m1, m1, 1);
            m1 = _mm_xor_pd(m1, SIGN_NP);

            l1 = _mm_mul_pd( a[0], _mm_shuffle_pd(b[0], b[0], …

我最近开始使用 SQLAlchemy，之前没有任何 SQL 知识。我一直面临的一个问题是如何引入多态行为。作为一个例子，考虑类似 Reddit 的 Web 应用程序；我们有一个模型Article和一个模型Comment，两者都可以投票：

class Article(Base):
    id       = Column(Integer, primary_key = True)
    data     = Column(Text)
    comments = relationship('Comment')
    #... more article-related attributes
    votes      = relationship('Vote')
    vote_ups   = Column(Integer, default = 0)
    vote_downs = Column(Integer, default = 0) 

class Comment(Base):
    id   = Column(Integer, primary_key = True)
    data = Column(Text)
    #... more comment-related attributes
    votes      = relationship('Vote')
    vote_ups   = Column(Integer, default = 0)
    vote_downs = Column(Integer, default = 0)

我想分离两个模型共有的投票属性，这样我就不必为每个可以投票的模型重复代码。

我的第一个想法是创建一个新VotesComponent模型，其中包含属性，

class …

在编程时,我经常遇到以下设计选择:用户创建一个对象并将其传递给另一个在第二阶段以某种方式处理的对象.

举个例子,你可以想象一个光线跟踪器.用户创建具有特定属性和调用的球体raytracer.addTraceable(sphere).现在,有三种方法可以让我想到这样做.

1. 光线跟踪器负责释放分配给球体对象的内存
2. 用户需要释放分配给sphere对象的内存.
3. 光线跟踪器只复制球体对象,用户和光线跟踪器都会释放它们的本地副本.

一般来说,在这种情况下,最好的设计选择是什么？除了我提到的那些(不包括智能指针)之外还有其他选择吗？

PS:在使用面向对象的方法时,我在普通C中遇到了同样的问题.

我想知道返回指向本地静态/全局变量的指针的函数是否可以像C++一样用作C语言中的左值,所以我尝试了它,看起来这是可能的.以下面的简单函数为例,

int* d(int a){
    static int* array = NULL;
    static int size = 0;
    if(a+1 > size){
        size = 2*(a+1);
        array = realloc(array, size * sizeof(int));
    }
    if(a == -1){
        free(array);
        return NULL;
    }
    return array + a;
}

这是一个简单的动态数组,你可以这样做*d(30) = 2,但由于每个编译单元只能有一个函数实例,所以我觉得这没有用.

因此,我想问一下,如果在C中有这个概念有任何有趣的用途.任何真正的应用程序也会很好.