[C11] 能否使用move()回傳一個新的物件但不copy物件

最近花了很多時間研究是否能以rvalue reference在不複製物件的狀態下回傳新物件
但我仍然找不到方法

一般講到這個問題 大家一定是會回答RVO(return value optimization)
雖然目前的comple大部份都會做到RVO 但我們還是不能說RVO一定會有

我天真的以為rvalue reference跟move可以讓function的新物件的scope在return之後繼續維持
但其實只是我誤會了這個新功能
move constructor/assigment的設計上還是要先construct物件
不論如何 move constructor還是會消耗新的空間與時間用在construct
move assigment也一定要先contruct物件才能再assign
我們能處理的是member variable要怎麼複製

閱讀更多

[Python] python的字串與轉碼問題:string and encode in 2.7/3.x

先以Python3為例子

[code lang=”python”]>>> s = ‘你好’
>>> len(s)
2
>>> s[0]
‘你’
>>> s[1]
‘好’
>>> b = s.encode(‘utf8′)
>>> b
b’\xe4\xbd\xa0\xe5\xa5\xbd’
>>> len(b)
6
>>> b[0]
228
>>> b[1]
189
>>> type(b)
<class ‘bytes’>
>>> type(s)
<class ‘str’>
[/code]

從上面可以看出來,在Python3裡面被單引號「’」或是雙引號「”」包起來的東西會被當成一個str。
在Python3裡面str是人類可讀的字串,所以中文的「你好」就會被拆成「你」「好」兩個字
實際上在記憶體中是沒辨法直接儲存中文,必須轉換成0與1的方式來儲存,但使用STR時沒必要去了解Python是怎麼儲存str。
我們還可以把str轉換成一連串數字,這件事情叫做「編碼(encode)」
可以想像成把人類可讀的文字轉成電腦可以儲存的電腦語言,Python3就叫做bytes。
一般來說目前最常用的編碼語言是「utf8」
「你好」轉成utf8就會變成6個byte

閱讀更多

[Python] 底線, name_mangling與private member

python並沒有所謂的private
但可以在member的前面加上一個底線 當作一個軟性的private
告訴其他人這個member不應讓其他人取用或修改 以達到安全性

我們也可以在member前面加上雙底線 這樣會產生name mangling的效果
但這樣也不能完全達到禁止存取

一般的情況下應該使用單底線來告知使用者即可(from fluent python ch9)

閱讀更多

[Python] default argument


def show_name(name = "no name"):
    print(name)

show_name("John")
#John
show_name()
#no name

只要在參數後面加個等於可以設定參數的預設值
但要小心不要使用可變(mutable)的容器當作預設值, ex: list, dict, set
不然會出現下面的問題

閱讀更多

[python] defaultdic, __call__

case1:
有時候我們會希望在dictionary中遞增value
但往往需要重複檢查key值是否存在並設定value為empty list, empty set或為0
這種情況使用setdefault或是sefaultdict就是一個好選擇

case2:
有時我們會希望function在執行時同時記錄一些狀態值
使用__call__來建立一個可以呼叫的物件

閱讀更多

[讀書心得] 鳳凰專案-看IT部門如何讓公司從谷底翻身的傳奇故事

FullSizeRender-2

醜話說在前這本書的翻譯品質並不好,一來可能是譯者的翻譯問題二來可能是本書原文作者用字方式較特別。我本人並沒有看過原文,但看過原文的朋友曾表示這本書的英文並不好理解。

撇開翻譯品質的問題,這本書是以小說方式解譯devops,故當成小說來閱讀應該不會有太大問題。因為我只有在硬體系統廠工作的經驗,閱讀時對於這本書常碰到的「deploy」問題較沒有概念,一些專有名詞如ITIL, ITSM也就略過不研究。

這本書以「第一人稱」來描寫比爾這個中階經理在CIO被FIRE後被拉上公司技術總管理人,負責理管全公司約100名工程師。書中的公司雖為一家汽車零件公司,但有許多複雜的IT系統負責生產管理、庫存、零售、薪資、財務等功能。

閱讀更多

[Python][C++] static method and inheritance

[code language=”cpp”]
#include <iostream>

using namespace std;

class Parent {
public:
void foo() {
cout << "foo of parent" << endl;
}
static void static_foo() {
cout << "static_foo of parent" << endl;
}
};

class Child : public Parent {
public:
void foo() {
cout << "foo of child" << endl;
}
static void static_foo() {
cout << "static_foo of child" << endl;
}
};

class DummyChild : public Parent {};

void demo() {
Parent parent;
Child child;
DummyChild dummyChild;

parent.foo(); //foo of parent
Parent::static_foo(); //static_foo of parent

child.foo(); //foo of child
Child::static_foo(); //static_foo of child

dummyChild.foo(); //foo of parent
DummyChild::static_foo(); //static_foo of parent

Parent *parentPtr;
Child *childPtr;

parentPtr = &child;
parentPtr->foo(); //foo of parent
//在一般的情況下 因為cpp是靜態語言 預設只會去找這個pointer class所屬的member function

childPtr = &child;
childPtr->foo(); //foo of child
}
[/code]

[code language=”cpp”]
class VirtualParent {
public:
//member function前面加個virtual就變成virtual function
//後面再加上 = 0;就是pure virtual function
virtual void foo() = 0;
virtual void foo2() {} //實作virtual function不是良好設計 但仍可編譯
};

class NonVirtualChild : public VirtualParent {
public:
//child必須實作pure virtual function
void foo() {
cout << "non virtual child" << endl;
}
//若parental有實作virtual function, child建議要overwrite
//但非強制overwrite
void foo2() {}
};

void demo1() {
//含有pure vitual function的class無法生成instance
//此class又稱abstract class(c++術語)或是interface(抽象講法)
//VirtualParent p;

NonVirtualChild c;
c.foo(); //non virtual child
}

class ConcreteParent {
public:
virtual void foo() {
cout << "concrete parent" << endl;
}
};

class ConcreteChild : public ConcreteParent {
public:
virtual void foo() {
cout << "concrete child" << endl;
}
};

void demo2() {
ConcreteParent* p = new ConcreteChild();
p->foo(); //concreate child;
//若呼叫的是virtual function, pointer會去table找出真正的member function
delete p;
}

int main() {
demo();
demo1();
demo2();
}

[/code]

[code language=”python”]
#Python
class Parent:
variable_foo = "variable_foo" #也是class variable
class_variable_foo = "class_variable_foo"

def __init__(self):
self.variable_foo = "init_foo" #object variable

def foo(self):
print("foo of parent, variable = {}, {}".format(self.variable_foo, self.class_variable_foo))

@staticmethod
def static_foo(*arg):
print("static_foo of parent: arg = {}".format(arg))

@classmethod
def class_foo(cls):
print("class_foo of parent, variable = {}, {}".format(cls.variable_foo, cls.class_variable_foo))

class Child(Parent):
variable_foo = "child_variable_foo" #也是class variable

def __init__(self):
self.variable_foo = "init_child_foo" #object variable

def foo(self):
print("foo of child, variable = {}, {}".format(self.variable_foo, self.class_variable_foo))

@staticmethod
def static_foo(*arg):
print("static_foo of child: arg = {}".format(arg))

@classmethod
def class_foo(cls):
print("class_foo of child, variable = {}, {}".format(cls.variable_foo, cls.class_variable_foo))

class DummyChild(Parent):
pass

parent = Parent()
parent.foo() # foo of parent, variable = init_foo, class_variable_foo
#Python會先去找object的variable 找不到時才會去找class的variable

Parent.class_foo() # class_foo of parent, variable = variable_foo, class_variable_foo
Parent.variable_foo = "changeable"
Parent.class_foo() # class_foo of parent, variable = changeable, class_variable_foo
#在Python裡面 class也是一個object 故在執行期改變class變數是OK的
#在C++ class不是object而是一個namespace 故呼叫class static function要用"::" 而非"."

Parent.static_foo() # static_foo of parent: arg = ()
Parent.static_foo("argument1", "arguments2") # static_foo of parent: arg = (‘argument1’, ‘arguments2’)
#在Python裡面 static method是沒辦法access class的attribute
#故可了解 Python的class method其實比較像C++的class static method

child = Child()
child.foo() # foo of child, variable = init_child_foo, class_variable_foo
child.class_foo() # class_foo of child, variable = child_variable_foo, class_variable_foo
child.static_foo() # static_foo of child: arg = ()

dummy = DummyChild()
dummy.foo() # foo of parent, variable = init_foo, class_variable_foo
DummyChild.class_foo() # class_foo of parent, variable = changeable, class_variable_foo
DummyChild.static_foo() # static_foo of parent: arg = ()
[/code]