标签: sequencing

根据C++ 14 [expr.call]/4:

参数的生命周期在定义它的函数返回时结束.

这似乎意味着参数的析构函数必须在调用函数的代码继续使用函数的返回值之前运行.

但是,此代码显示不同:

#include <iostream>

struct G
{
    G(int): moved(0) { std::cout << "G(int)\n"; }
    G(G&&): moved(1) { std::cout << "G(G&&)\n"; }
    ~G() { std::cout << (moved ? "~G(G&&)\n" : "~G()\n"); }

    int moved;
};

struct F
{
    F(int) { std::cout << "F(int)\n"; }
    ~F() { std::cout << "~F()\n"; }
};

int func(G gparm)
{
    std::cout << "---- In func.\n";
    return 0;
}


int main()
{
    F v { func(0) };
    std::cout << "---- End of main.\n"; …

所以我在这里读到:https://stackoverflow.com/a/598150/2642059这是非法的:

foo(i++, i++);

但我相信这是因为没有强制序列,我理解的是初始化列表的情况.这个法律代码也是如此吗？

const int foo[] = { i++, i++ };

我有一个mysql表,其中每一行在"序列"列中都有自己的序列号.但是,当一行被删除时,会留下一个空白.所以...

1
2
3
4

... ...变

1
2
4

有没有一种巧妙的方法来"重置"排序,所以它在一个SQL查询中再次连续？

顺便说一下,我确信这个过程有一个技术术语.任何人？

更新:"序列"列不是主键.它仅用于确定记录在应用程序中显示的顺序.

我正在玩Haskell 计算Levenshtein距离,并对下面的性能问题感到有点沮丧.如果你为Haskell实现最"正常"的方式,就像下面(dist)一样,一切正常:

dist :: (Ord a) => [a] -> [a] -> Int
dist s1 s2 = ldist s1 s2 (L.length s1, L.length s2)

ldist :: (Ord a) => [a] -> [a] -> (Int, Int) -> Int
ldist _ _ (0, 0) = 0
ldist _ _ (i, 0) = i
ldist _ _ (0, j) = j
ldist s1 s2 (i+1, j+1) = output
  where output | (s1!!(i)) == (s2!!(j)) = ldist s1 s2 (i, j)
               | otherwise …

我创建了一个读取ID对列表的函数(即[("A","B"),("B","C"),("C","D"),...]和序列ID从头到尾包括任何分支机构.

每个有序ID列表都保存在一个名为Alignment的类中,该函数使用递归来处理分支,方法是从分支从主列表中拆分的ID开始创建一个新的对齐.

我发现使用某些输入可以达到Python设置的最大递归限制.我知道我可以使用sys.setrecursionlimit()来增加这个限制,但由于我不知道有多少分支组合是可能的,所以我想避免这种策略.

我一直在阅读几篇关于将递归函数转换为迭代函数的文章,但是我无法确定处理这个特定函数的最佳方法,因为递归发生在函数的中间并且可以是指数函数.

你们有没有提出任何建议？

谢谢,Brian

代码发布如下:

def buildAlignments(alignment, alignmentList, endIDs):
    while alignment.start in endIDs:

        #If endID only has one preceding ID: add preceding ID to alignment
        if len(endIDs[alignment.start]) == 1:
            alignment.add(endIDs[alignment.start][0])

        else:

            #List to hold all branches that end at spanEnd
            branches = []

            for each in endIDs[alignment.start]:

                #New alignment for each branch
                al = Alignment(each)

                #Recursively process each new alignment
                buildAlignments(al, branches, endIDs)

                branches.append(al)
            count = len(branches)
            i = 0
            index = 0

            #Loop through branches by length …

我有以下代码片段，将文件按原样复制到构建目录：

for m in std_mibs:
    print("Copying", m)
    bld(name       = 'cpstdmib',
        rule       = 'cp -f ${SRC} ${TGT}',
        #source     =  m + '.mib',
        source     =  bld.path.make_node(m + '.mib'), # <-- section 5.3.3 of the waf book
        target     =  bld.path.get_bld().make_node(m + '.mib')
        )

我看到这条规则虽然（从打印中）被命中，但副本似乎并没有发生！我还更改了源以使用如图所示的 waf 书第 5.3.3make_node节中的示例，但仍然没有运气！我在这里错过了一些明显的东西吗！？

bld.add_group()