小编qba*_*qba的帖子

可能重复:
如何在C
数组初始化中初始化数组,引用前一个元素ok？

我想知道在c/c ++标准中进行这样的初始化是否安全:

int a = 5;
int tab[] = { a , tab[0] + 1 , tab[1] };

它成功编译并执行gcc 4.5和clang 2.9,但它总是真的吗？

打印此表给出5 6 6.它在全球范围内初始化.

通常它在c和c ++中都很有趣,但我想在c ++中使用它:)

我是haskell的新手,我正在寻找一些标准函数来处理索引列表.

我确切的问题是我想在每5个后删除3个元素.如果它不够清楚这里是插图:

OOOOOXXXOOOOOXXX...

我知道如何使用许多参数编写巨大的函数,但有没有聪明的方法来做到这一点？

我想创建自己的monad.这就是我写的:

data LeafConType a = LeafCon (a,Int,Int)

instance Monad (LeafConType ) where
return = LeafCon 
lc@(LeafCon (t,i,n)) >>= f = if i>=n
                                then lc
                                else f (t,i,n)

但这不行.Ghc说:

leafcon.hs:26:1:
    Occurs check: cannot construct the infinite type: a = (a, Int, Int)
    When generalising the type(s) for `return'
    In the instance declaration for `Monad LeafConType'

leafcon.hs:27:1:
    Occurs check: cannot construct the infinite type: a = (a, Int, Int)
    When generalising the type(s) for `>>='
    In the instance declaration for `Monad LeafConType' …

我正在编写自己的图形库(是的,它的作业:)并使用cuda快速完成所有渲染和计算.

我有绘制填充三角形的问题.我这样编写了一个进程绘制一个三角形.当场景中有很多小三角形时它工作得很好,但是当三角形很大时它会完全破坏性能.

我的想法是做两次通过.首先计算仅包含扫描线信息的选项卡(从此处绘制到此处).这将是每个过程计算的三角形,就像当前算法一样.在第二遍中,确实绘制了每个三角形有多个进程的扫描线.

但它会足够快吗？也许有更好的解决方案？

我有foreach函数,它在它包含的每个元素上调用指定的函数.我希望从这个元素中得到最少但我不知道如何编写lambda或函数,甚至是一个能够管理它的类.谢谢你的帮助.

o.foreach( lambda i: i.call() )

要么

o.foreach( I.call )

我不喜欢制作列表或其他对象.我想通过它迭代并找到min.

我设法写一个做思考的课程,但应该有一个更好的解决方案:

class Min:                                           
    def __init__(self,i):                        
        self.i = i                              
    def get_min(self):                               
        return self.i                                
    def set_val(self,o):                             
        if o.val < self.i: self.i = o.val

m = Min( xmin )
self.foreach( m.set_val )                            
xmin = m.get_min()

好的,所以我想我的.foreach方法是非蟒蛇的想法.我应该做我的Class iterable,因为你的所有解决方案都基于列表,然后一切都会变得更容易.

在C#中,lambda函数没有问题,所以我觉得python也很强大.

我的问题是我需要迭代数组并根据每个元素计算一些值.我正在为数组寻找类似折叠的函数,但标准库似乎对数组非常无用.或者我错过了什么？

另一种解决方案可能是将数组"绑定"到列表中.绑定意味着我不想复制该数组.这可能吗？

顺便说一句,这一切都与普通阵列有关.

无论是int还是类实例,都有可能通过引用复制变量吗？

我的目标是拥有两个相同对象的列表,当一个更改时,更改在第二个中可见.

换句话说,我需要指针:/

我只想要int,float和其他通常由value复制的标准类型,强制通过引用复制.这将使我的代码更加一致.

如果没有这种可能性,类包装器是最好的解决方案.

我需要使用一个成员函数指针,它接受在其他代码中使用的基类的参数.好吧,我只想做[某事]如下面的例子.这段代码工作正常,但我想知道这样的演员是否总是安全的？我不能在这里做dynamic或static投.

#include <cstdio>                                                   

class C
{                                                           
public:                                                             
        C () : c('c') {}                                            
        virtual ~C() {}                                             

        const char c;                                               
};                                                                  

class D : public C
{                                                
public:                                                             
        D () : d('d') {}                                            
        virtual ~D() {}                                             

        const char d;                                               
};                                                                  

class A 
{                                                           
public:                                                             
        A () {}                                                     
        virtual ~A() {}                                             

        void f( C& c ) { printf("%c\n",c.c); }                      
        void g( D& d ) { printf("%c %c\n",d.c,d.d); }               
};                                                                  

int main (int argc, char const* argv[])                             
{                                                                   
        void (A::*pf)( …