小编Car*_*ood的帖子

我很惊讶 boost::date_time 似乎可以写入它无法读取的日期/时间字符串。

考虑以下示例代码：

#include <boost/date_time/local_time/local_time.hpp>
#include <iostream>
#include <locale>

class PointTime : public boost::local_time::local_date_time {
    typedef boost::local_time::local_time_input_facet   input_facet_t;
    typedef boost::local_time::local_time_facet         output_face_t;

  public:
    static input_facet_t const s_input_facet;
    static output_face_t const s_output_facet;
    static std::locale const s_input_locale;
    static std::locale const s_output_locale;

  public:
    PointTime(std::string const& str);
};

PointTime::input_facet_t const PointTime::s_input_facet("%Y-%m-%dT%H:%M:%S%q", 1);
PointTime::output_face_t const PointTime::s_output_facet("%Y-%m-%dT%H:%M:%S%q",
    boost::local_time::local_time_facet::period_formatter_type(),
    boost::local_time::local_time_facet::special_values_formatter_type(),
    boost::local_time::local_time_facet::date_gen_formatter_type(),
    1);
std::locale const PointTime::s_input_locale(std::locale::classic(), &PointTime::s_input_facet);
std::locale const PointTime::s_output_locale(std::locale::classic(), &PointTime::s_output_facet);

PointTime::PointTime(std::string const& str) : boost::local_time::local_date_time(boost::local_time::not_a_date_time)
{
  std::istringstream is(str);
  is.imbue(s_input_locale);
  is >> *this;
  std::string s;
  is >> s; …

我正在将AutoTools项目移植到CMake。

AutoTools的作用：

• 建立一些静态库
• 建立一些共享库并将静态库链接到共享库
• 构建可执行文件，将其链接到共享库

我已经设法使用CMake进行了以下操作：

• 建立一些静态库- add_library(staticfoo <src>)
• 建立一些共享库- add_library(sharedfoo SHARED <src>)并将它们链接-target_link_libraries(sharedfoo staticfoo)
• 构建可执行文件，将其链接到共享库- target_link_libraries(exe sharedfoo)，但这也再次将静态库拖入其中。

因此，可执行文件的结果链接命令除了共享外还具有静态库。这与AutoTools项目生成的命令不对应。

我已经尝试过了target_link_libraries(sharedfoo PRIVATE staticfoo)，但这并不能将符号从静态库获取到共享库的接口中。

如何获得没有“传递”行为的符号？

（以与平台无关的方式）

我希望有一个通用的模板类，该类允许用户传递容器使用：

template<class Container>
struct Sum
{
  Container m_terms;
...

其他类将从中派生，例如，

class MySum : public Sum<std::vector<int>>
{
...

要么

class MySum4 : public Sum<std::array<int, 4>>
{
...

容器需要从构造函数初始化。我最初的想法是使用std::initializer_list，例如

MySum ms{1, 2, 3, 4};

这将需要添加以下构造函数：

template<class Container>
struct Sum
{
  Container m_terms;

  Sum(std::initializer_list<typename Container::value_type> const& il) :
    m_terms(il) { }
...

class MySum : public Sum<std::vector<int>>
{
  using Sum<std::vector<int>>::Sum;
...

但是我又如何才能使MySum4正常工作？一个array不采取std::initializer_list<>。

这是显示编译器错误的更完整的代码：https : //wandbox.org/permlink/CZW3YaKdInwZZD8e

我正在为 gnome 编写一个支持插件的应用程序。每个插件将包含一个glade 文件和一个python 脚本。

如何将插件中的空地文件嵌入到主界面中。

插件空地文件应包含一个页面/选项卡，并将嵌入到主界面的笔记本中。

请帮忙。

我正在使用C和unix低级套接字处理聊天应用程序.我已经成功制作了控制台版本,但我想为应用程序制作一个GUI.我想将GTK用于GUI.我的问题是如何"同步"套接字和GUI.因为我必须调用gtk_main()作为最后一个GTK语句,并且应用程序本身是一个无限循环.如何在收到消息时更新GUI？

请原谅我的英语.

我正在尝试使用css文件更改GtkButton的背景颜色,但我不能.我尝试了一些我在网上找到的例子,但都没有用.我发布了两个例子.一个在Python 3.2.3中,另一个在C中我使用的是Gtk + 3.6和Kubuntu 12.10.

这是其中一个的代码:

from gi.repository import Gtk, Gdk

class MainWindow(Gtk.Window):
    def __init__(self):
        super().__init__()
        vbox = Gtk.Box(spacing=10,orientation=Gtk.Orientation.VERTICAL)
        self.add(vbox)

        self.entries = [ Gtk.Entry() for i in range(3) ]
        for e in self.entries:
            vbox.pack_start(e, True, True, 0)
            e.connect("changed", self.on_entry_changed)
            e.set_text('123')

        button=Gtk.Button(label='ok')
        vbox.pack_end(button,True,True,0)

    def on_entry_changed(self,entry):
        ctx = entry.get_style_context()
        if not entry.get_text().isnumeric():
            ctx.add_class('invalid')
        else:
            ctx.remove_class('invalid')
cssProvider = Gtk.CssProvider()
cssProvider.load_from_path('style.css')
screen = Gdk.Screen.get_default()
styleContext = Gtk.StyleContext()
styleContext.add_provider_for_screen(screen, cssProvider,
Gtk.STYLE_PROVIDER_PRIORITY_USER) # With the others GTK_STYLE_PROVIDER_PRIORITY values get the same result.

window = MainWindow() …

我是C++模板的新手.谁能解释为什么我的专用构造函数永远不会被执行.它删除const和引用运算符时工作.

#include<iostream>
#include<string>

using namespace std;

template<typename T>
class CData
{
public:
    CData(const T&);
    CData(const char*&);
private:
    T m_Data;
};

template<typename T>
CData<T>::CData(const T& Val)
{
    cout << "Template" << endl;
    m_Data = Val;
}
template<>
CData<char*>::CData(const char* &Str)
{
    cout << "Char*" << endl;
    m_Data = new char[strlen(Str) + 1];
    strcpy(m_Data, Str);
}

void main()
{
    CData<int> obj1(10);
    CData<char*> obj2("Hello");
}

输出是

模板

模板

考虑以下测试片段（这些是文件“declare_test”的内容）：

function do_foobar ()
{
  unset FOOBAR
  declare -- FOOBAR="default"
  FOOBAR="override"

  echo "At end of do_foobar: FOOBAR = \"$FOOBAR\""
}

从命令提示符运行 do_foobar 会产生：

$ source declare_test
$ do_foobar
At end of do_foobar: FOOBAR = "override"
$ echo "FOOBAR=\"$FOOBAR\""
FOOBAR=""

换句话说，函数 FOOBAR 内部具有预期值，即“覆盖”，但在函数 FOOBAR 立即被取消设置之后。

如果我们更改 do_foobar 并删除“declare”行，则结果是：

$ do_foobar
At end of do_foobar: FOOBAR = "override"
$ echo "FOOBAR=\"$FOOBAR\""
FOOBAR="override"

所以，现在 FOOBAR 没有被重置。请注意，删除的声明的功能是设置FOOBAR。如果我们不删除声明而是删除“FOOBAR=”override”行，则结果将变为：

$ do_foobar
At end of do_foobar: FOOBAR = "default"
$ echo "FOOBAR=\"$FOOBAR\""
FOOBAR="" …

实际上,我正在使用libev; 但在幕后这是使用epoll(我只在Linux上).当我添加一个观察者来读取文件并且所有数据都已被读取时,我确实得到一个回调,即有数据要读取,但是read(2)返回0(EOF).那时我必须停止观察者,否则它会继续告诉我有东西要读.但是,如果我停止观察者,然后其他一些进程将数据附加到该文件,那么我将永远不会看到它.

获得通知的正确方法是,在我读完之前可以读取的文件中是否有附加/附加数​​据？

我更喜欢libev方面的答案,但是更低级别也会这样做(我可以将其转化为如何用libev做到这一点).

请考虑以下代码:

struct Foo {
  std::string s;
  Foo(std::string s_) : s(s_) { }
};

Foo* f(std::string s)
{
  return new Foo(s);
}

在那里f()可以用左值或右值调用std::string,或与char const*造成临时(但这是一样的右值我恢复).例如:

int main()
{
  f("test");
  f(std::string());
  std::string s("test");
  f(std::move(s));
  std::string s2("test");
  f(s2); // This MUST cause one copy.
}

只有在最后一种情况下才需要一份副本.在所有其他情况下,我希望根本不会复制,并且std::string只构造一次(在分配中Foo).

这可能吗？如果是这样,签名会如何f()？

编辑:

使用Tracked from cwds我创建了一个小测试程序,其中有一个string类在构造,移动等时打印.对于main()函数,请看这个blob.

上面的程序给出了以下输出:

NOTICE  : Calling f("test")... <unfinished>
TRACKED :     string0*
TRACKED :     string1*(string0)
TRACKED :     string2*(string1) …

在大型项目上运行 cmake 时，它​​可以并行调用给定的 cmake 函数吗？

我担心的是，当这个（用户定义的）函数在缓存中存储某些内容时，这会与并行执行发生冲突；当函数确实并行执行时，cmake 如何处理这个问题，或者我是否必须确保即使调用同一函数也永远不会使用具有不同值的相同（缓存）变量名？

编辑（见评论）：

我写了下面的函数，

function(CW_SYS_CACHELINE_SIZE)
  if (NOT DEFINED CACHE{cw_cv_sys_cacheline_size})
    set(CMAKE_TRY_COMPILE_CONFIGURATION "Release")
    try_run(RUN_WORKS
            COMPILE_WORKS
            ${CMAKE_CURRENT_BINARY_DIR}/cw_utils_sys_cacheline_size
            ${CW_SYS_CACHELINE_SIZE_MODULE_PATH}/CW_SYS_CACHELINE_SIZE.c
            COMPILE_OUTPUT_VARIABLE COMPILE_OUTPUT
            RUN_OUTPUT_VARIABLE RUN_OUTPUT)
    if (NOT COMPILE_WORKS)
      message(FATAL_ERROR "Failed to compile test program 
CW_SYS_CACHELINE_SIZE.c: ${COMPILE_OUTPUT}")
    elseif (NOT RUN_WORKS EQUAL 0)
      message(FATAL_ERROR "Failed to run test program CW_SYS_CACHELINE_SIZE.c: ${RUN_OUTPUT}")
    else ()
      set(cw_cv_sys_cacheline_size ${RUN_OUTPUT} CACHE INTERNAL "")
    endif ()
  endif()
endfunction()

由于该函数不接受参数，因此所使用变量的内部值每次都应该相同；但我还有其他非常相似的函数，它们几乎做同样的事情，除了它们编译和测试不同的.c文件。

因此，每个函数都可以有不同的 值RUN_WORKS，该值（事实证明）作为 写入缓存INTERNAL。假设我没有终止程序，而是用RUN_WORKS此处的值做其他事情。那么可能是我首先运行这个函数（其中RUN_WORKS为 true），然后运行另一个设置RUN_WORKS为 false 的函数。

如果我再次运行 cmake …