小编Cha*_*_99的帖子

我有两个清单,让我们说:

keys1 = ['A', 'B', 'C', 'D', 'E',           'H', 'I']
keys2 = ['A', 'B',           'E', 'F', 'G', 'H',      'J', 'K']

如何创建没有重复项的合并列表,以保留两个列表的顺序,将缺少的元素插入它们所属的位置？像这样:

merged = ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K']

请注意,可以将元素与相等进行比较,但不进行排序(它们是复杂的字符串).这些元素不能通过比较来排序,但它们的顺序基于它们在原始列表中的出现次数.

如果出现矛盾(两个输入列表中的顺序不同),则包含所有元素的任何输出都是有效的.当然,如果解决方案在保留大部分订单时显示"常识",则可获得奖励积分.

再次(正如一些评论仍然争论它),列表通常不会在共同元素的顺序上相互矛盾.如果他们这样做,算法需要优雅地处理该错误.

我开始使用.next()遍历列表的版本,以推进包含不匹配元素的列表,但.next()只是不知道何时停止.

merged = []
L = iter(keys1)
H = iter(keys2)
l = L.next()
h = H.next()

for i in range(max(len(keys1, keys2))):
  if l == h:
    if l not in merged:
      merged.append(l)
    l = L.next()
    h = H.next()

  elif l not in keys2:
    if …

我正在尝试使用QtCreator(2.7.2)+ QT(5.1.0)来构建在桌面(Linux)和移动(Android)平台上运行的应用程序.

为此,我需要根据目标平台使用不同的预构建库.如何在.pro文件中指定它？

该向导仅提供linux/mac/windows作为平台选择

unix:!mac {
message("* Using settings for Unix/Linux.")
LIBS += -L/path/to/linux/libs
}

我试过了

android { 
message("* Using settings for Android.")
LIBS += -L/path/to/android/libs
}

但是对于两个构建目标,只unix:!mac执行/评估获取.

所以我的问题是:如何检测.pro文件中的构建目标(现在在QtCreator中称为"Kits")并相应地更改库定义？

到目前为止,我只发现了如何指定平台(这似乎是我正在构建的平台而不是FOR)或构建变体RELEASE/DEBUG.我发现的其他事情说我应该LIB+=在目标平台上加上前缀win32:LIB+=.但同样,这将不起作用android.也许我在平台上使用了错误的语法(arm-v7上的android 4.2).

我正在尝试调用一个重载函数,该函数对具有默认值参数的函数指针进行操作.

void originalFunction1 (int a = 0) {printf("I'm #1 and a is %d",a);}
void originalFunction2 () {printf("I'm #2");}

void overloadedFunction (void (*fptr)(void))
{
  fptr();
}

void overloadedFunction (void (*fptr)(int))
{
  overloadedFunction( (void(*)(void)) fptr);
}

int main() 
{
  overloadedFunction(originalFunction1);
  overloadedFunction(originalFunction2);

  // output is:
  // I'm #1 an a is -1073743272
  // I'm #2
}

正如这个问题的答案所指出的,默认值不是函数签名的一部分,也不能在(函数指针 - )参数定义期间重复.正如我的示例所示,它们可以被抛弃用于调用,但它们将不会被初始化为其默认值.

有什么方法可以解决这个问题吗？

我无法修改原始功能,但我知道默认值.我可以修改主重载函数以及重定向.永远只会在没有参数的情况下调用fptr.实际上,有更多的重载函数,因为返回类型也不同,但我可以更容易地抛弃它.

我需要一个只读的std:map数据结构,这意味着我必须用数据填充一次,然后只读取这些值,永远不要更改它们或添加其他值.

我的非const版本看起来像这样:

//in .h
#include <string>
#include <map>

std::map<std::string, int> myMap;
void initMap();

//in .cpp
#include "foo.h"

void initMap() {
  myMap["Keys"] = 42;
}

然后我会initMap()在我的代码中调用一次并完成.

现在我已经在这里阅读了几个问题,实现地图的常数似乎并非易事.

制作它std::map<std::string, const int>不会让我填写它initMap().使用非const temp填充它并且定义上的复制构造函数也不起作用,因为复制构造函数不容易将非const版本作为输入.

使它成为const std::map<std::string, int>(我可以在定义期间填充非const副本)将禁止使用[]运算符进行值访问.

那么有没有办法实现(值)const-ness并初始化结构(最好是在头文件中)？

顺便说一句:C++ 0x和C++ 11也不boost::是一个选项.

我可能想要实现不可能的,但StackExchange总是让我感到惊讶,所以请你去看看:

我需要将名称映射到整数.名字(约2k)是独一无二的.该列表不会有任何添加或删除,并且这些值在运行时不会更改.

将它们作为const int变量实现,可以对存在和类型进行编译时检查.这在代码中也非常清晰和冗长.很容易发现错误.

实现它们为std::map<std::string, int>我提供了很大的灵活性来构建名称以查找字符串操作.我可以使用它来将字符串作为参数提供给函数,这些函数可以通过在该字符串后附加前缀/后缀来查询列表中的多个值.我还可以通过从循环变量创建键名的数字部分来循环遍历多个值.

现在我的问题是:是否有一种结合两种优势的方法？缺少编译时检查(特别是对于密钥存在)几乎杀死了我的第二种方法.(特别是如果密钥不存在,则会std::map无声地返回0,这会导致很难找到错误.)但循环和前/后缀添加功能非常有用.

我更喜欢不使用任何其他库(如boost)的解决方案,但请尽可能地建议它们,因为我可能无论如何都可以重新实现它们.

关于我对地图做什么的一个例子:

void init(std::map<std::string, int> &labels)
{        
  labels.insert(std::make_pair("Bob1" , 45 ));
  labels.insert(std::make_pair("Bob2" , 8758 ));
  labels.insert(std::make_pair("Bob3" , 436 ));
  labels.insert(std::make_pair("Alice_first" , 9224 ));
  labels.insert(std::make_pair("Alice_last" , 3510 ));
}

int main() 
{      
  std::map<std::string, int> labels;
  init(labels);

  for (int i=1; i<=3; i++)
  {
    std::stringstream key;
    key << "Bob" << i; 
    doSomething(labels[key.str()]);
  }

  checkName("Alice");
}

void checkName(std::string name)
{
  std::stringstream key1,key2;
  key1 << name << "_first";
  key2 << …

尝试使用类型提示执行 Python (3.8.8) 并从 mypy (0.931) 中获取我无法真正理解的错误。

import xml.etree.ElementTree as ET
tree = ET.parse('plant_catalog.xml')  # read in file and parse as XML
root = tree.getroot()  # get root node
for plant in root:  # loop through children
    if plant.find("LIGHT") and plant.find("LIGHT").text == "sun" 
        print("foo")

这会引发 mypy 错误Item "None" of "Optional[Element]" has no attribute "text"。但为什么？我确实在 if 子句的前半部分检查plant.find("LIGHT")返回的可能性。None如果第一部分失败，则访问.text属性的第二部分甚至不会执行。

如果我修改为

    lights = plant.find("LIGHT")
    if lights:
        if lights.text == selection:            
            print("foo")

错误消失了。

这是因为plant对象在第一次检查和第二次检查之间仍然可能发生变化吗？但是分配给变量不会自动复制内容，它仍然只是对可能更改的对象的引用。那为什么第二次就通过了呢？

（是的，我知道重复 …

我需要将非POD类型传递给C++函数.我想修改该函数内部的值,但我不希望该更改在该函数之外可见.

我的第一个选择是传递值,这会创建一个副本.

void myFunction (NonSimpleObject foo) {
  foo = ~foo;
}

我也可以通过引用传递,这在函数调用期间更快,但是我需要在里面创建一个不影响外部值的副本;

void myFunction (NonSimpleObject &foo) {
  NonSimpleObject foo_internal = ~foo;      
}

要向调用者发出不会修改外部值的信号,我想包含一个const限定符.当按值调用时,这当然是隐含的,但我想更加冗长.但传递一个const值将迫使我在里面创建第二个副本来修改该值,这也与const限定符最初使用的内容有些相反.

void myFunction (const NonSimpleObject foo) {
  NonSimpleObject foo_internal = ~foo;
}

传递一个const引用都会向调用者发出信号,表明外部值没有改变,只需要在函数内部有一个副本.

void myFunction (const NonSimpleObject &foo) {
  NonSimpleObject foo_internal = ~foo;      
}

哪一个最适合我的目的(良好的性能,对调用者来说冗长)以及优点/缺点是什么？

这也归结为以下问题:在参数传递期间复制内部函数而不是复制是否有任何优势,反之亦然？

我正在使用一个带有自定义数据类型的库,它会使[]运算符重载,以允许对所调用的数据进行类似数组的访问MType.

我已经创建了这些对象的实际数组,如下所示: MType mtypearray[3];

现在访问数据时,我不确定哪个索引用于什么.

mtypearray[a][b] = 5;

a索引是使用[] -overload进入自定义MType还是进入通常大小为3的数组MType mtypearray[3];？

我的实验表明,a它实际上是数组索引,b用于自定义类型索引.但这似乎与通常处理多维数组的方式相反.

[]是否真的从左到右而不是从右到左进行评估？

在我使用的代码中,我在头文件中找到了一个类声明,其中包含指向const的指针作为成员,在头文件中使用'new'定义.

匹配的"删除"位于析构函数中(也在标题中定义).

这个用法好吗？它会造成内存泄漏吗？只有在通过删除(使用new创建时)或超出范围(在堆栈上创建时)销毁该类的对象时,才会调用析构函数.但是'new'不在构造函数中,而是类声明的一部分.这不是早点执行的吗？甚至可能在解析标题时？是否保证我与析构函数中的删除相匹配？

class Foo {
public:
  explicit Foo(){}
  ~Foo() {
    delete this->bar;
  }

private:
  const Baz* bar = new Baz();
};