小编Ben*_*ler的帖子

我正在尝试为我编写的程序添加Unicode支持.我的ASCII代码已编译并具有以下行:

std::stringstream stream("abc");
std::istream_iterator<std::string> it(stream);

我将其转换为:

std::wstringstream stream(L"abc");
std::istream_iterator<std::wstring> it(stream);

我在istream_iterator构造函数中收到以下错误:

error C2664: 'void std::vector<_Ty>::push_back(std::basic_string<_Elem,_Traits,_Alloc> &&)' : cannot convert parameter 1 from 'std::basic_string<_Elem,_Traits,_Alloc>' to 'std::basic_string<_Elem,_Traits,_Alloc> &&'
1>          with
1>          [
1>              _Ty=std::wstring,
1>              _Elem=wchar_t,
1>              _Traits=std::char_traits<wchar_t>,
1>              _Alloc=std::allocator<wchar_t>
1>          ]
1>          and
1>          [
1>              _Elem=char,
1>              _Traits=std::char_traits<char>,
1>              _Alloc=std::allocator<char>
1>          ]
1>          and
1>          [
1>              _Elem=wchar_t,
1>              _Traits=std::char_traits<wchar_t>,
1>              _Alloc=std::allocator<wchar_t>
1>          ]
1>          Reason: cannot convert from 'std::basic_string<_Elem,_Traits,_Alloc>' to 'std::basic_string<_Elem,_Traits,_Alloc>'
1>          with
1>          [
1>              _Elem=char,
1>              _Traits=std::char_traits<char>, …

我的代码全部位于我的计算机/ a/b/c/d/e/myCode上的以下目录中.当我想编译project1时,我很生气地键入make/a/b/c/d/e/myCode/project1.为了解决这个问题,我在bashrc中创建了一个函数,如下所示:

function make_project { make /a/b/c/d/e/myCode/$1; }

然后我称之为:

make_project project1

这很好用.唯一的问题是我没有project1的自动完成功能.因此,如果我有一个名为my_complicatedly_named_project的复杂名称的项目,我将需要输入整个名称.是否有任何方法让bash知道参数是/ a/b/c/d/e/myCode /中的目录它可以自动完成吗？

我有一个函数Foo可以获取两个模板 argsL3HdrType和L4HdrType. 我收到一个数据包并解析它，然后需要调用该函数。我的代码目前看起来像：

ParsedPacket parsed_packet = parser.Parse(packet);
if (parsed_packet.ip_version() == IPv4 && parsed_packet.ip_proto() == TCP)
  Foo(parsed_packet.L3Header<ipv4_hdr>(), parsed_packet.L4Header<tcp_hdr>());
if (parsed_packet.ip_version() == IPv6 && parsed_packet.ip_proto() == TCP)
  Foo(parsed_packet.L3Header<ipv6_hdr>(), parsed_packet.L4Header<tcp_hdr>());
if (parsed_packet.ip_version() == IPv4 && parsed_packet.ip_proto() == UDP)
  Foo(parsed_packet.L3Header<ipv4_hdr>(), parsed_packet.L4Header<udp_hdr>());
if (parsed_packet.ip_version() == IPv6 && parsed_packet.ip_proto() == UDP)
  Foo(parsed_packet.L3Header<ipv6_hdr>(), parsed_packet.L4Header<udp_hdr>());

我的问题是，有没有办法减少这种代码重复？类似的东西：

Foo<parsed_packet.GetL3HeaderType(), parsed_packet.GetL4HeaderType()>(...);

这显然不起作用，因为在编译时不知道给定数据包的标头类型。

重复的根源是两个不同的 if 语句正在检查IPv4并将其映射到ipv4_hdr. 如果我可以在代码中的一个地方指定IPv4映射到ipv4_hdrthen 这将使代码随着选项的数量线性增长而不是指数增长，因为我可以以某种方式编写：

if (parsed_packet.ip_version() == IPv4) {
  using L3HeaderType = ipv4_hdr;
} …

我想访问类之外的模板参数.我通常这样做如下:

template <class T>
class A
{
  typedef typename T T;
}

A<int>::T;

我希望能够对非类型模板参数执行相同的操作.这不起作用:

template <int T>
class A
{
  typedef typename T T;
}

A<3>::T;

我将澄清为什么我需要这个.我想定义第二个类如下:

template <class C>
class B
{
  static int func() {return C::T;}
}

B<A<3> >::func();

这样做的正确方法是什么？非常感谢你.

我有一个std::vector我知道的是有序的.使用std::binary_search我可以在日志时间中查找元素是否在向量中.遗憾的是,std::binary_search如果成功,则不返回向量中元素的索引(或者如果它不知道如何访问它).std::find将给我一个元素的迭代器,但它没有使用向量排序的事实,因此它以线性时间而不是日志时间运行.我知道我可以轻松实现自己的二进制搜索算法,但我想知道是否有办法在标准中执行此操作.

在C++之前的11天里,编写更好的做法是:

if (ptr == NULL)

而不是:

if (!ptr)

这有两个原因.它效率更高,因为它不需要强制转换为bool.并且无法保证宏NULL确实会评估为布尔值false.这在C++ 11中仍然如此吗？写作是否更可取

if (ptr == nullptr)

而不是

if (!ptr)

或者现在是第二次罚款？

我的代码如下:

HTML

<div class="divs">
  <div class="row">row 0</div>
  <div class="not-row"></div>
  <div class="row">row 1</div>
  <div class="not-row"></div>
  <div class="row">row 2</div>
  <div class="not-row"></div>
  <div class="row">row 3</div> 
  <div class="not-row"></div>
</div>

CSS

.row:nth-child(even) {
  background: #fff;
}

.row:nth-child(odd) {
  background: #eee;
}

这应该绘制两行灰色和两行白色的背景.不幸的是,它将所有背景描绘成灰色.我究竟做错了什么？

我尝试使用nth-of-type而nth-child不是改变了什么.

jsFiddle例子

我有一个函数,它选择a的随机元素List并返回它.列表可以并且非常长(数百万个元素),并且此函数每秒被调用数千次,因此效率很重要.

我目前的实现如下:

MyClass getRandomElement(List<MyClass> myClasses) {
  return myClasses.get(getRandomNumber(myClasses.size()));
}

此解决方案存在两个问题.

1. List.get不保证可以参加比赛O(1).LinkedList例如,实现它O(n).
2. size不保证O(1)在所有List实现中运行.

第二点不是很有说服力,因为我所知道的所有实现都实现了它O(1).第一点是有问题的.

是否有任何方法可以保证(不是编译/运行时异常)实现O(1).我想把界面改为:

MyClass getRandomElement(ArrayList<MyClass> myClasses)

这太严格了.我希望用户能够使用一个调用此函数ImmutableList.它甚至被推荐.

我可以声明该值是ArrayList或的实例ImmutableList.这将排除任何其他O(1)实现,但我可以忍受它.然而,它是运行时实施而不是编译时执行.我不确定这项检查的运行时开销是多少.

这是最好的做法吗？

我想让一个函数返回一个保证实现两个接口的对象。在编译时不一定知道确切的对象。我的代码看起来像：

class HelloWorld {

  public interface A {}
  public interface B {}

  public static class C implements A, B {}
  public static class D implements A, B {}

  public static <T extends A & B> void g(T t) {}

  public static <T extends A & B> T f(boolean b) {
    if (b)
      return new C(); // Doesn't compile
    return new D(); // Doesn't compile
  }

  public static void main(String []args){
    g(f(true));
    g(f(false));
    <what_should_I_write_here> x = f(<user_inputted_boolean>); 
  }
}

尝试编译时出现以下错误：

HelloWorld.java:13: …

我有一个功能void Foo(MyType* mt)。我希望调用者能够将任何指针类型传递给该函数（例如unique_ptr、shared_ptr或iterator），而不需要传递原始指针。有什么办法可以表达这一点吗？我可以写：

template <typename T>
void Foo(T t);

这将起作用，因为它仅在T支持operator->并且operator*我在内部使用时才进行编译Foo，它也仅在T具有相同的接口时才起作用MyType，但未在 API 中指定我希望模板参数是指向的指针似乎是错误的MyType。我还可以编写自己的包装器：

template <typename T>
class PointerWrapper {
 public:
  PointerWrapper(T* t) : raw_ptr(t) {}
  PointerWrapper(const std::unique_ptr<T>& t) : raw_ptr(t.get()) {}
  ...
 private:
  T* raw_ptr;
};

void Foo(PointerWrapper<MyType> mt);

这看起来很笨重，因为我需要为每个智能指针类型扩展 PointerWrapper。

有公认的方式来支持这一点吗？