小编Ano*_*ity的帖子

当我在某个时刻添加一个cout时,我很惊讶地看到我的程序突然变得安静,所以我隔离了负责的代码:

std::stringstream data;
data<<"Hello World\n";
std:std::fstream file{"hello.txt", std::fstream::out};
file<<data.rdbuf();
std::cout<<"now rdbuf..."<<std::endl;
std::cout<<data.rdbuf()<<std::endl;
std::cout<<"rdbuf done."<< std::endl;

该计划在没有最后一场比赛的情况下悄然退出.到底是怎么回事？如果我改变了最后一个.rdbuf(),.str()那么它就完成了.

给定一个长度数组size和n该数组的索引，如何包装索引以使其始终在 内size-1？对于正数，它很简单n % size，但是如何在n为负数时实现向后环绕？

我想出了什么：

int wrap(int size, int n) {
    if (n >= 0)
        return n % size;
    else
        return abs(size + n) % size;
}

但这仅适用于n <= size; 如何使它适用于任何人n？

预期输出：

wrap(4, -1) == 3
wrap(4, -2) == 2
wrap(4, -3) == 1
wrap(4, -4) == 0
wrap(4, -5) == 3
wrap(4, -6) == 2
wrap(4, -7) == 1
wrap(5, -8) == 0

我有一个看起来像这样的 Makefile：

CC=cc
CFLAGS=-g -std=c99 -Wfatal-errors
OBJS=$(wildcard *.o)

all: main.o cmdargs.o io.o
    $(CC) -o app $(OBJS)

main.o: main.c
    $(CC) -c main.c $(CFLAGS)
cmdargs.o: cmdargs.c
    $(CC) -c cmdargs.c $(CFLAGS)
io.o: io.c
    $(CC) -c io.c $(CFLAGS)

clean:
    @rm -rf app $(OBJS)

每当我make all在干净之后运行时，都会出现错误

抄送-o

对“main”的未定义引用

但是当我第二次运行它时，一切都按预期进行。脚本有什么问题，我们该如何修复它？

在我的项目中,我有一个如下所示的makefile:

CXX = clang++
CFLAGS = -std=c++11 
COMMON_SOURCES = file1.cpp file2.cpp
TARGET_SOURCES = main.cpp
TEST_SOURCES = run_tests.cpp test_file1.cpp test_file2.cpp
COMMON_OBJECTS = $(COMMON_SOURCES:.c=.o)
TARGET_OBJECTS = $(TARGET_SOURCES:.c=.o)
TEST_OBJECTS = $(TEST_SOURCES:.c=.o)
EXECUTABLE = build/application
TEST_EXECUTABLE = build/tests
.PHONY: all target tests
all: target tests
target: $(EXECUTABLE)
tests: $(TEST_EXECUTABLE)
clean:
    rm build/tests & rm build/application &
$(EXECUTABLE): $(COMMON_OBJECTS) $(TARGET_OBJECTS)
    $(CXX) $(CFLAGS) $(LDFLAGS) $^ -o $@
$(TEST_EXECUTABLE): $(COMMON_OBJECTS) $(TEST_OBJECTS)
    $(CXX) $(CFLAGS) $(LDFLAGS) $^ -o $@
.c.o:
    $(CXX) $(CFLAGS) $< -o $@

这让我运行make tests或者 …

auto obj = new Object;
obj->~Object();
delete obj;

我知道这很不寻常,但它是否定义了行为？它会引起任何令人惊讶的问题吗？

我有一个包含其他列表的列表,并且只想从其他列表中的第n个项目创建新列表.

my_list = [[1,2,3],['a','b','b'],[100,200,300]]

new_list = make_new_list(mylist, index=2)

new_list = [2,'b',200]

我知道如何设计一个抓住所有第二个元素的函数,但我也知道总有一些pythonic列表理解能够更顺利地完成.什么是列表理解？

从字典对象列表开始,如何根据键获取包含一些字典值的新列表？

例如:

my_list = [ {'foo':1},{'bar':2},{'foo':3} ]
new_list = grab_values(my_list, 'foo')

我们想要什么:

new_list = [1, 3]

线程具有以下控制流程:

mutex.lock()
if (condition) {
    // do synced things
    mutex.unlock();
    // do parallel things
} else {
    // do other synced things
    mutex.unlock();
    // do other parallel things
}

注意这四个do部分如何执行不同的事情.

如何将直接调用替换为锁定和解锁std::lock_guard而改为使用？

假设有一个字典像

d1 = {
    'a b':1,
    'c-d':2,
    'Ef':3
}

我想运行一个根据某些规则重命名所有键的函数，例如小写并将空格和 - 更改为 _。从而得到结果：

d2 = {
    'a_b':1,
    'c_d':2,
    'ef':3
}

这个问题与本网站上有关重命名字典键的其他类似问题之间的区别在于，这里我们事先不知道这些列。所以我们想对所有键运行重命名函数（以​​规范化它们或类似的东西）。

从一些元组列表开始.

a = [(10,10),(20,20)]
b = [(15,15),(25,25)]

我们可以使用什么列表理解来创建新列表,其中的项目a, b按大小排序？

c = [(10,10),(15,15),(20,20),(25,25)]

如果调用超类启动函数的以下用法之间的重要区别怎么办？

class Child_1(Parent):
    def __init__(self):
        super(Child, self).__init__()

class Child_2(Parent):
    def __init__(self):
        super(Parent, self).__init__()

class Child_3(Parent):
    def __init__(self):
        Parent.__init__(self)

如何重构以下代码以使用推荐的lock_guards？

bool locked = false;
bool sync() {
    if (locked) {
        mutex.unlock();
    } else {
        mutex.lock();
    }
    locked = !locked;
    return locked;
}

期望的使用模式:

while (sync()) {
    // do safe things
}

基本上我试图模仿withPython 的声明.例:

from multiprocessing import Lock
with Lock():
    # do safe things

我有一个模板化的类,我想给出一个参数包类型方法,如下所示:

template<class T>
class MyClass {
public:
    template<class U>
    add(U u) {}

    template<class U, typename... Args>
    add(U u, Args... args) {
    }
};

请注意,T并U始终是相同的类型.

我的问题很简单:是否有可能直接引用T而不是U在这种情况下？我的工作是什么,但如果我T直接提到的话会更清楚意图是什么.