小编Kon*_*lph的帖子

为什么以下命令在行结束之前不会产生填充空格的水平规则？

Hello \rule[0.5em]{\fill}{1pt}

我的理解是,这应该打印文本" Hello"后跟一个水平规则,该规则一直延伸到行尾,类似于\hfill实际等效的宏\hspace\fill.- 但实际上,这个命令只生成文本" Hello",没有规则.

我知道效果可以产生,\hrulefill但它不能在这里使用,因为我想要一个凸起的规则,\hrulefill不能\raisebox与我一起工作,我希望我的规则挂在基线之上(最好在线的中间).

GMan发布了一个美味的auto_cast"运算符"代码,允许在C++中编写如下代码:

float f = 4.0f;
int i = auto_cast(f);
// instead of:
int j = static_cast<int>(f);

或者,更突出的是,

T x = value;
typename nested_type<with, template_arguments>::type y = auto_cast(x);
// instead of
typedef typename nested_type<with, template_arguments>::type my_type;
my_type z = static_cast<my_type>(x);

基本上,操作员可以很好地从a中删除不必要的冗余static_cast,同时仍然是安全的.它甚至比防止意外不匹配类型更安全static_cast:

int i = 1234;
short s = static_cast<char>(i); // s == -46, not 1234!

但是,j_random_hacker注意到运算符中存在缺陷:

static_cast允许向下转换,这可能是不安全的.

实际上,auto_cast应该禁止向下倾斜,因为它们可能会失败:

class base { };
class derived …

我有一个messenger依赖于printer实例的类.printer是一个多态基类,实际对象传递给messenger构造函数.

对于非多态对象,我只需执行以下操作:

class messenger {
public:
    messenger(printer const& pp) : pp(pp) { }

    void signal(std::string const& msg) {
        pp.write(msg);
    }

private:
    printer pp;
};

但是什么时候printer是多态基类,这不再起作用(切片).

考虑到这一点,做这项工作的最佳方法是什么

1. 我不想传递指向构造函数的指针,并且
2. 本printer类不应该需要一个虚拟的clone方法(=需要依靠拷贝构造).

我不想传递指向构造函数的指针,因为API的其余部分正在使用真实对象,而不是指针,并且在此处将指针作为参数会令人困惑/不一致.

在C++ 0x下,我或许可以使用a unique_ptr和模板构造函数:

struct printer {
    virtual void write(std::string const&) const = 0;
    virtual ~printer() { } // Not actually necessary …
};

struct console_printer : public printer {
    void write(std::string const& msg) const {
        std::cout …

以下MyStruct(标记MyStruct)的定义和MyStruct类型的类型定义似乎完全可以通过gcc(至少4.6.2)和g ++来完成.

typedef struct MyStruct {
  int a;
  int b;
} MyStruct;

我的问题是:它是否容易出错(在C和/或C++中)或使用标签名称与类型名称相同的错误样式？

根据http://www.eetimes.com/discussion/programming-pointers/4024450/Tag-vs-Type-Names,它不是:

我永远不明白为什么他们为标签和typedef使用不同的名称,当一个名称做得很好时:

typedef struct tree_node tree_node;

Run Code Online (Sandbox Code Playgroud)

但我经常看到代码样式如下:

1. typedef struct tagMyStruct {...} MyStruct;
2. typedef struct myStruct {...} MyStruct;`
3. typedef struct _MyStruct {...} MyStruct; <是的,我知道下划线+大写字母

在每种情况下,有人在某种程度上使标签名称与类型名称不同.它背后有任何实际原因吗？

旁注:我使用的是C++编译器,但我想与这些定义C兼容(我知道这对c ++来说是不好的风格).出于维护某些调试工具的可用性的原因,我需要所有标记名称都是有意义的(不是自动生成的__unknown_something标记,如果是未命名的结构,您可以,例如,在visual studio类视图中查看).

同样的问题/问题适用于工会和枚举.

我的R工作流通常是这样的,我打开一个文件,我输入R命令,我想在一个单独打开的R shell中执行这些命令.

最简单的方法是source('the-file.r')在R里面说.然而,这总是重新加载整个文件,如果处理大量数据可能需要相当长的时间.它还要求我再次指定文件名.

理想情况下,我只想从文件中获取特定行(或行)(我正在使用复制和粘贴不起作用的终端).

source似乎没有提供此功能.有没有另一种方法来实现这一目标？

我是否遗漏了某些内容,或者无法从lambda函数返回值,例如..

Object test = () => { return new Object(); };

要么

string test = () => { return "hello"; };

我得到一个构建错误"无法将lambda表达式转换为'string'类型,因为它不是委托类型".

这就像这个语法分配lambda而不是lambda的结果,我没想到.我可以通过将函数分配给Func并按名称调用它来实现所需的功能,但这是唯一的方法吗？

请不要"为什么你需要这样做？" 关于我的例子.

提前致谢!

我正在尝试使用{}列表进行一些测试.当我在VS2015中编译它时,输出是

copy A 0

Run Code Online (Sandbox Code Playgroud)

只是不明白,复制构造函数在哪里调用？

#include <iostream>

struct A
{
    A() = default;
    A(int i) : m_i(i) {}
    A(const A& a)
    {
        std::cout << "copy A " << m_i << std::endl;
    }
    int m_i = 0;
};

struct B
{
    B(const A& a) : m_a(a) {}
    B(const A& a1, const A& a2) {}
    A m_a;
};

int main()
{
    A a1{1}, a2{2};
    B b({ a1, a2 });
    return 0;
}

调用forward()父方法的最合适方法是Module什么？例如，如果我对nn.Linear模块进行子类化，我可能会执行以下操作

class LinearWithOtherStuff(nn.Linear):
    def forward(self, x):
        y = super(Linear, self).forward(x)
        z = do_other_stuff(y)
        return z

但是，文档说不要forward()直接调用该方法：

尽管需要在此函数中定义前向传递的方法，但应该在之后调用 Module 实例而不是 this，因为前者负责运行已注册的钩子，而后者则默默地忽略它们。

这让我觉得super(Linear, self).forward(x)可能会导致一些意想不到的错误。这是真的还是我误解了继承？

我有一个函数模板，它接受许多不同的类型作为输入。在这些类型中，只有其中一种具有getInt()功能。因此，我希望代码仅针对该类型运行该函数。请提出一个解决方案。谢谢

#include <type_traits>
#include <typeinfo>

class X {
    public:
    int getInt(){
        return 9;
    }
};

class Y{

};

template<typename T>
void f(T& v){
    // error: 'class Y' has no member named 'getInt'
    // also tried std::is_same<T, X>::value 
    if(typeid(T).name() == typeid(X).name()){
        int i = v.getInt();// I want this to be called for X only
    }
}

int main(){
    Y y;
    f(y);
}

出于教育目的，我希望能够首先为字符串创建哈希，然后从该哈希创建 RSA 数字签名，以便结果与一次性使用 SHA256withRSA 时的结果相同。这样我想确认我完全理解当我们调用 SHA256withRSA 时实际自动完成的所有步骤。

我还有一个问题。数字签名是基于哈希还是基于 Base64 编码的哈希？

下面是我当前正在使用的代码，这是代码的输出，它显示这两种方法产生不同的签名，这意味着我缺少 soma 手动步骤。

AUTOMATICALLY SIGN & VERIFY
SIGNATURE = Hj6a86sR2cJoQFolbxj0blk2I9CAdTdx6WOles5t/pyUyJwa9rp2/SRx2wyXWgc6GsvoZYGLUedeJ2Lklm5hYgT/TtNBATk5eChgfkJMz3NBIRPrsl7ZPG7Wvo4VmHsPpoZZ8PdRk8qY9RLou86OyIqRcX62isuV+e/0deHJ+yTZz4vqA3y+PE4yRFp96A8sKw5VlDnByn7bsxM/QOS+sQWTsETzU9s4YSRfKNq1Urn8/VDoel7n0ORjR918P+0kwE+G77bAOI70yQZorvmbgrMLSBJeVzkKzM/YECLWyrJsqdjfp86FkA9MPGB1V6rO8q8m5GhNoJOmNhC7Ek95Bw==

MANUALLY SIGN & VERIFY
HASH      = lDlahWCWx2b5TYUji52uPeReSW7vbro2wXuRsPKmOdA=
SIGNATURE = gsxw7UQpqni5HyPAw8wI2pvepbrDzizkOvO0hab1+7vi4EaYJi3n4lvnkBTOU5LXQKLZGzJcug0mL2pL/PVh8lrvzZ/F9CxULLxKpayrNkvL9yEWMvcfcku9Go5EGrxSzD7VYvkwOzHvGe4GgUGD1JOjvzXBAfJRT8h/wnZi9IPA9n31/tWI2eFw17Js/gymElycp7pjrpEhUNe/IVTP9HVfRQfAxEDAPW8GY/WFdxbD3Jk05LKvpTxua4jzCX9wJh/s8aiT9OvEXh3/zt06JSEpfgf+CpkOFJupmRhsgqebPfVQEo24ctw1DnipKkL771mm30bFcm/FF1reXuOqqQ==

public class Main {

  //====================================================================================
  // MAIN
  //====================================================================================
  public static void main(String[] args) throws Exception {

    //CREATE DATA
    String            dataString = "Data to be encrypted";
    byte[]            dataBytes  = dataString.getBytes();

    //CREATE KEYS
    KeyPairGenerator  keyPairGenerator = KeyPairGenerator.getInstance("RSA");
                      keyPairGenerator.initialize(2048);
    KeyPair           keyPair    = keyPairGenerator.generateKeyPair();
    PrivateKey        privateKey = keyPair.getPrivate();

    //AUTOMATICALLY SIGN & VERIFY
    System.out.println("\nAUTOMATICALLY SIGN …