小编BЈо*_*вић的帖子

我目前正在阅读Rober Martin(UncleBob)的"清洁代码",并且一般都喜欢UncleBob的沉思.但是,当我读到他避免使用像"IPerson"这样的接口前缀时,我有点困惑.他说:"我不希望我的用户知道我正在为他们提供一个界面".

从TDD /注入角度思考,我总是非常有兴趣告诉我正在处理接口的类的"用户".主要原因是我认为接口在系统的不同"代理"之间收缩.在我的系统的一个角落工作的代理,不应该知道另一个代理工作的具体实现; 他们只应该交换合同,并期望在不知道如何履行合同的情况下履行合同.另一个但也非常重要的原因是可以完全模拟界面,从而使单元测试更容易.你可以在具体课上嘲笑多少是有限的.

因此,我更愿意想象我确实在交接接口......或者以接口作为参数.但是因为UncleBob是我们社区中的重量级冠军,而我只是另一位flyweigth桌面骑师,我想知道我是否遗漏了一些东西.

我坚持使用接口是不对的？

几天前在Facebook上的演讲 - 幻灯片,视频,Andrei Alexandrescu谈到可能证明我们错了的共同直觉.对我来说,幻灯片7中出现了一个非常有趣的观点,他指出假设"更少的指令=更快的代码"是不正确的,更多的指令并不一定意味着更慢的代码.

这就是我的问题:他的谈话的音质(大约6:20分钟)不是那么好,我不太理解这个解释,但从我得到的是他将退役指令与算法的最优性进行比较绩效水平.

但是,根据我的理解,这是不可能做到的,因为这是两个独立的结构层面.说明(特别是实际上已退役的说明)是一项非常重要的措施,基本上可以让您了解实现目标的绩效.如果我们省略指令的延迟,我们可以推断出更少的退出指令=更快的代码.现在,当然有些情况下,在循环内执行复杂计算的算法即使在循环内执行也会产生更好的性能,因为它会更早地破坏循环(想想图遍历).但是,与复杂程度的算法进行比较而不是说这个循环有更多指令并且比另一个更好会不会更有用？从我的观点来看,更好的算法最终会有更少的退役指令.

有人可以帮助我了解他的例子,以及如何(显着)更多退休指令可以带来更好的表现吗？

std :: strlen不处理不是\ 0终止的c字符串.它有安全版吗？

PS我知道在c ++中应该使用std :: string而不是c字符串,但在这种情况下,我的字符串存储在共享内存中.

编辑

好的,我需要补充一些解释.

我的应用程序从共享内存(有一定长度)获取一个字符串,因此它可以表示为一个字符数组.如果库中有一个错误写入此字符串,则该字符串不会被终止,并且strlen可能会失败.

我想知道为什么try-except比下面的程序中的if慢.

def tryway():
    try:
        while True:
            alist.pop()
    except IndexError:
        pass

def ifway():
    while True:
        if alist == []: 
            break
        else:
            alist.pop()
if __name__=='__main__':
    from timeit import Timer
    alist = range(1000)
    print "Testing Try"
    tr = Timer("tryway()","from __main__ import tryway")
    print tr.timeit()
    print "Testing If"
    ir = Timer("ifway()","from __main__ import ifway")
    print ir.timeit()

我得到的结果很有趣.

Testing Try
2.91111302376
Testing If
0.30621099472

任何人都可以解释为什么尝试这么慢？

如果有一个POD结构,带有一些成员变量,例如:

struct foo
{
   short a;
   int b;
   char c[50];
   // ...
};

有没有办法以字节为单位获取成员变量的大小,而无需创建此类型的对象？

我知道这会奏效:

foo fooObj;
std::cout << sizeof( fooObj.a ) << std::endl;
std::cout << sizeof( fooObj.b ) << std::endl;
std::cout << sizeof( fooObj.c ) << std::endl;

以下内容是否会被编译器优化并阻止构造对象？

std::cout << sizeof( foo().a ) << std::endl;

考虑以下库,可以在任何程序执行之前预先加载:

// g++ -std=c++11 -shared -fPIC preload.cpp -o preload.so
// LD_PRELOAD=./preload.so <command>
#include <iostream>

struct Goodbye {
    Goodbye() {std::cout << "Hello\n";}
    ~Goodbye() {std::cout << "Goodbye!\n";}
} goodbye;

问题是,虽然goodbye总是调用全局变量的构造函数,但是没有为某些程序调用析构函数,例如ls:

$ LD_PRELOAD=./preload.so ls
Hello

对于其他一些程序,析构函数按预期调用:

$ LD_PRELOAD=./preload.so man
Hello
What manual page do you want?
Goodbye!

你能解释为什么在第一种情况下没有调用析构函数吗？编辑:上面的问题已经得到解答,那就是程序可能会使用_exit(),abort()来退出.

然而:

有没有办法在预加载的程序退出时强制调用给定的函数？

我有大约1000个类,我需要计算它的属性数.我有以下代码:

    public static int NumberOfProperties()
    {
        Type type = typeof(C507);
        return type.GetProperties().Count();
    }

我可以将其复制并粘贴到每个更改typeof参数的类中,但这看起来有点单调乏味.

反正有没有做一个扩展方法来做到这一点var nop = C507.NumberOfProperties();？

我创建了两个简单的函数来获取模板参数和一个定义类型的空结构:

//S<T>::type results in T&
template <class T>
struct S
{
    typedef typename T& type;
};

//Example 1: get one parameter by reference and return it by value
template <class A>
A
temp(typename S<A>::type a1)
{
    return a1;
}

//Example 2: get two parameters by reference, perform the sum and return it
template <class A, class B>
B
temp2(typename S<A>::type a1, B a2)//typename struct S<B>::type a2)
{
    return a1 + a2;
}

参数类型应用于struct S以获取引用.我用一些整数值调用它们但编译器无法推断出参数:

int main()
{
    char c=6;
    int …

我正在阅读文本文件中的行,我想知道这是否是一个好方法？我必须编写函数numberoflines来减少number_of_lines variable一个,因为在while循环中,对于它读取的每一行,它都会向number_of_lines变量添加2.

#include <iostream>
#include <fstream>
using namespace std;

int number_of_lines = 0;

void numberoflines();
int main(){
    string line;
    ifstream myfile("textexample.txt");

    if(myfile.is_open()){
        while(!myfile.eof()){
            getline(myfile,line);
            cout<< line << endl;
            number_of_lines++;
        }
        myfile.close();
    }
    numberoflines();

}

void numberoflines(){
    number_of_lines--;
    cout<<"number of lines in text file: " << number_of_lines << endl;
}

还有其他更容易更好的方法吗？

如果我有以下代码:

template <typename T = int>
struct mystruct {
  using doublestruct = mystruct<double>;
}

mystruct<>::doublestruct obj;

这会实例化mystruct<int>模板吗？或者只是mystruct<double>实例化？