第十三號艦隊
0%

Posted on Edited on In

在Linux常常遇到這種情況，記錄一下。
使用sudo執行指令的時候，常常會xxx is not in the sudoers file. This incident will be reported.
表示你的用戶沒有權限使用sudo，必須修改/etc/sudoers這個文件，修改方式如下。

  1. 進入Super user mode

    1
    $ su -

  2. 修改文件權限

    1
    $ chmod u+x  /etc/sudoers

  3. 修改/etc/sudoers內容，在root ALL=(ALL) ALL底下加上一行且存檔。

    1
    xxx ALL=(ALL) ALL

    這裡的xxx就是你的用戶名稱

  4. 回復文件權限

    1
    $ chmod u-x  /etc/sudoers

Posted on Edited on

最近在看Dynamic programming language的時候，注意到了這個特性。
根據Wiki給的定義

When I see a bird that walks like a duck and swims like a duck and quacks like a duck, I call that bird a duck.

一般OOP的觀念，就是定義一組Interface為公約數。不受Interface的約束，而動態語言是在執行時檢查是否滿足所需條件。

以下是Ruby的範例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
class Duck
  def quack
    puts "Quaaaaaack!"
  end
 
  def feathers
    puts "The duck has white and gray feathers."
  end
end
 
class Person
  def quack
    puts "The person imitates a duck."
  end
 
  def feathers
    puts "The person takes a feather from the ground and shows it."
  end
end
 
def in_the_forest duck
  duck.quack
  duck.feathers
end
 
def game
  donald = Duck.new
  john = Person.new
  in_the_forest donald
  in_the_forest john
end
 
game

動態語言的特性，就是在執行的時刻檢查類別的完整性，如果把上面Person的feathers拿掉，也必須在執行時才會發現錯誤。

如果是傳統競泰語言的話，如何顯示這種特性
C++有兩種方式。

一者是上面介紹的Interface contract

1
2
3
4
5
6
7
8
9
10
11
12
13
14
class IAnimal {
public:
	virtual void Quack() = 0;
	virtual void Feathers() = 0;
};

class Duck : public IAnimal {};
class Person : public IAnimal  {};

void in_the_forest(IAnimal *pDuck)
{
	pDuck->Quack();
	pDuck->Feathers();
}

這種方式可以在Runtime的時候傳入某個滿足此Contract的物件，因此改變其行為。
不過缺點也是顯而易見的，一旦介面修改之後，所有有關的程式碼都要更著修改。所以一般的建議就是一旦介面固定之後就不要更改。

因此衍生了第二種方法，Template。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
class Duck {
public:
	void Quack();
	void Feathers();
};
class Person {
public:
	void Quack();
	void Feathers();
};
template <typename T>
void Program(T& duck)
{
	duck.Quack();
	duck.Feathers();
}

C++的Template會在C編譯時檢查所有約束條件，因此叫做Static Polymorphism，跟用Interface的Dynamic Polymorphism不同，Runtime沒有擴展性。

Posted on Edited on

這次介紹另一個C++11重要的特性Variadic templates

從printf說起

相信每個寫程式的人，就算沒用過printf，也聽過printf的名字，printf的徒子徒孫大概跟Unix的子孫一樣多。而一般的printf使用方式就類似如此。

1
2
int my_printf(const char * format, ...);
my_printf("%d + %d = %d", a, b, a + b);

在設計一個通用函數的時候，無法知道後面參數有多少個，因此需要一個支持不定參數的機制。
從上面的程式碼看出，我們支援不定參數的語法就是...來表示。
而在C語言如何實做這樣的機制，可以參考MSDN上的範例。

Marco也支援不定參數

在C99標準裡，Macro支持不定參數，不過Visual Studio至今不支援C99。
我們可以寫類似這樣的Macro

1
#define dprintf(enable, ...) dprintf_impl(__FILE__, __LINE__, enable, __VA_ARGS__)

在參數列的最後面寫 …，然後就可以用 VA_ARGS 代表 … 所傳入的參數。

如何讓Template支援不定參數

從C++98談起

在實作Command Design Pattern的時候，常常需要把外部函數的參數原封不動的傳遞至內部函數，解決方法大概就像這樣。

1
2
3
4
5
6
7
8
9
10
11
12
#define P1 typename T1
#define A1 T1 &&v1
#define V1 v1
#define P2 typename T1, typename T2
#define A2 T1 &&v1, T2 &&v2
#define V2 v1, v2
#define P3 typename T1, typename T2, typename T3
#define A3 T1 &&v1, T2 &&v2, T3 &&v3
#define V3 v1, v2, v3
template <P1> void outer(A1) { inner(V1); }
template <P2> void outer(A2) { inner(V2); }
template <P3> void outer(A3) { inner(V3); }

這方案的缺點大概有以下幾點

  • 可代入的參數數量有限 (雖然可以手動擴充)
  • 程式碼難以維護，核心的程式碼不多，但是重複的程式碼很多
  • 編譯速度緩慢
  • 極度依賴Preprocessor
    加上C++11的新特性之後，問題變得更複雜了。

C++11時期

來個最簡單的範例

1
2
3
4
5
6
7
8
9
template <typename... Args>
class VariadicTemplate {};
template <typename T, typename ...Args>
class VariadicTemplate1 {};

VariadicTemplate<> a;				// VariadicTemplate1接受無任何型別
VariadicTemplate<int> b;
VariadicTemplate1<> c;				// VariadicTemplate1至少需要一個型別，編譯器會報錯
VariadicTemplate1<double, int, string> d;

在Args左邊出現...時，表示Args是一個Template type parameter pack，如上面的最後一行，T就是double，而Args就是int, string，除了類別之外，非類別的template paramter也可以這樣使用。如下

1
2
3
template <unsigned ...dims>
class Array {};
Array<3, 4, 5> arr;

而Function template也可以像Class Template一樣使用不定參數

1
2
template <typename ...Args>
void func(Args ...args);

這裡的Args不是Type，args也不是一個value，所以以下的程式碼會出問題

1
2
3
typedef Args MyList;
MyList var;
auto copy = args;

而sizeof也跟著Variadic templates而新增新特性，sizeof...可以印出Args到底有多少個參數

1
2
3
4
5
6
template <typename... Args>
struct VariadicTemplate {
    static const unsigned short int size = sizeof...(Args);
};
cout << VariadicTemplate<>::size << endl;	// 0
cout << VariadicTemplate<int, int, int>::size << endl; // 3

如何解決之前的問題

用新的特性同時解決perfect forwarding跟Variadic templates

1
2
template <typename ...Ts>
void outer(Ts&& ...args) { inner(std::forward<Ts>(args)...); }

如何抽取單一個型別與參數

透過Template specification來實作

1
2
3
4
5
6
7
8
template <typename T>
void print(T &&v);
template <typename T, typename ...Args>
void print(T &&v, Args ...args)
{
	print(std::forward<T>(v));
	print(std::forward<Args>(args)...);
}

還有其他未介紹到的特性，基於所知有限<無法完全說明，可以參考Variadic Templates (Revision 3) Draft跟Variadic Templates are Funadic

Posted on Edited on

前一陣子都在忙C++ Grandmaster的比賽，沒什麼時間紀錄一些東西，最近對Functional Programming感到興趣，找Haskell當作的入門的開始。做些紀錄。

安裝

以Ubuntu為例，先安裝Haskell。

1
$ apt-get install ghc

接著就能用ghci進入直譯器了，用Ctrl+D退出ghci。

Script Programming

有兩種方式可以達成

在ghci當中載入

首先我們先來寫一個test.hs文件

lang: bash
1
2
3
$ cat > test.hs << EOF
add x y = x + y
EOF

在ghci中載入test.hs

lang: bash
1
2
3
4
5
6
$ghci
Prelude> :l test
[1 of 1] Compiling Main             ( test.hs, interpreted )
Ok, modules loaded: Main.
*Main> add 3 4
7

當成一般的 Script 使用

這個方案是要加上 #!/usr/bin/runghc 且Script當中需要有main存在
以下是個範例

lang: bash
1
2
3
4
5
6
7
$ cat > hello.hs << EOF
> #!/usr/bin/runghc
> main=putStrLn "Hello, Haskell from elf"
> EOF
$ chmod +x hello.hs
$ ./hello.hs 
Hello, Haskell

編譯成執行檔

同樣的，這個方案也需要有main存在

lang: bash
1
$ ghc hello.hs -o hello

其他有關Haskell的教學

網路上可以找到不少，先以這幾個當入門教材

Haskell入門的5個步驟

Haskell在线教程

Tutorials - Haskell

Posted on Edited on

這篇文章主要是Rvalue References: C++0x Features in VC10, Part 2的閱讀筆記，在原文撰寫過程當中，規格有所變動，因此根據最新的規則做補充說明。

Copy Problems

C++98/03的時候，最令人詬病的問題，就是建立太多臨時物件，Value Semantics的意思就是複製出來的物件跟原先是獨立的，不會互相干擾

Lvalue and Rvalue

在C++98/03時期，有這麼一條規則Every C++ expression is either an lvalue or an rvalue.，Lvalue是在運算過後留下來的續存物件，而Rvalue是運算過後生命期就結束的臨時物件。
殂此之外，C++98/03裡還有一條規則A function call is an lvalue if and only if the result type is a reference

1
2
3
4
5
6
7
8
9
string one("one");
const string two("two");
string three() { return "three"; }
const string four() { return "four"; }

one;     // modifiable lvalue
two;     // const lvalue
three(); // modifiable rvalue
four();  // const rvalue
  • Type&可以繫結到一個modifiable lvalue，而如果要繫結到modifiable rvalue，C++規定禁止(Visual C++除外，可以把警告層級從3調到4，會警告你這樣很危險，而gcc跟clang則是輸出錯誤訊息。)
  • const Type&可以繫結到任何一種型態，不過不能對Rvalue做任何修改，因此不能對即將消滅的臨時物件採取任何行動

而在C++11之後，引進了Rvalue reference，解決了這個問題。

  • Type&&可以繫結到一個modifiable rvalue，而不能繫結到modifiable lvalue，需要強制轉型。
  • const Type&&可以繫結任何形態

每個reference都有一個名字，所以Bind到Rvalue的refernce，他是一個Lvalue，因此以下的程式碼。

1
2
3
4
void print(const string&) { cout << "print(const string&)" << endl; }
void print(string&&) { cout << "print(string&&)" << endl; }
void RvalueTest(string&& str) { print(str); }
RvalueTest(string());

在RValueTest執行結束之前，str是個合法的物件，因此被當作Lvalue，會執行第一個print。

為了學習Rvalue的觀念，自行打造move跟forward函數。

先看C++11之後引進的Reference Collapsing Rules

  • T& + & => T&
  • T&& + & => T&
  • T& + && => T&
  • T&& + T&& => T&&

而Move的用途就是明確指出不管物件是Lvalue或Rvalue，一律轉成Rvalue就是了。
而Forward的用途把外面的參數跟語意原封不動的傳進去內部，是Lvalue就是Lvalue，而Rvalue就是Rvalue。
先從比較簡單的Move開始看起，我門打造的第一版Move大概像這樣。
由於Move是個template function，必須進行Template Argument Deduction，此時引進了一條新的規則。
如果傳進來的是Lvalue的話，將會推導成T&，反之如果是Rvalue的話，就會推導成T(根據Reference Collapsing Rules，T和T&&都符合要求，為了解決歧異性，這邊強制要求推導成T)

1
2
3
4
5
template <typename T>
T&& Move(.... value)
{
	return static_cast<T&&>(value);
}

這邊先來決定如何傳遞參數，Call by value第一個被否決，接著就是T&跟T&&的選擇，根據前面的Reference Collapsing Rules，如果是T&的話一律會摺疊成T&，而T&無法繫結至modifiable rvalue，而如果是T&&的話，不管Lvalue跟Rvalue都可以順利繫結。

接著我們來測試第一版的程式碼

1
2
3
4
quark(Move(up));
quark(Move(down));
quark(Move(strange()));
quark(Move(charm()));

印出的結果是

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
t: up
T: string&
T&&: string&

t: down
T: const string&
T&&: const string&

t: strange()
T: string
T&&: string&&

t: charm()
T: const string
T&&: const string&&

顯然結果錯了，原因在於實際參數是Lvalue的話，T會被推導成U&，而T&&的結果依然是U&，變成Move傳回去的語意是個Lvalue，因此導致上面的結果。
所以我們要做的，就是把U&或U&&一律轉成U&&，也就是std::remove_refernce存在的理由。改寫我們的程式，先用RemoveRefenece取得Primitive Type, 然後加上&&之後就可以得到正確的值。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
template <typename T>
struct RemoveReference {
	typedef T type;
};
template <typename T>
struct RemoveReference<T&> {
	typedef T type;
};
template <typename T>
struct RemoveReference<T&&> {
	typedef T type;
};
template <typename T>
typename RemoveReference<T>::type&& Move(T&& t)
{
	return static_cast<RemoveReference<T>::type&&>(t);
}

gcc的實作就類似於這樣。
接著來討論forward該怎麼做，從上面我們可以知道，我們只能用T&&來傳遞參數。
先來一組helper function來驗證程式的正確性。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
void inner(std::string &str)
{
	cout << "inner(std::string &str)" << endl;
}
void inner(const std::string &str)
{
	cout << "inner(const std::string &str)" << endl;
}
void inner(const std::string&& str)
{
	cout << "inner(const std::string&& str)" << endl;
}
void inner(std::string&& str)
{
	cout << "inner(std::string&& str)" << endl;
}
template <typename T> 
void outer(string&& value)
{
	return inner(Forward(value));
}
outer(up);
outer(down);
outer(strange());
outer(charm());

而我們第一版的Forward的實作

1
2
3
4
5
template <typename T>
T&& Forward(T& value)
{
	return static_cast<T&&>(value);
}

輸出結果則是

1
2
3
4
inner(std::string&& str)
inner(const std::string&& str)
inner(std::string&& str)
inner(const std::string&& str)

從上面知道，value是個左值，所以Type是U&，T被推導成U，T&&被強制轉換成右值，所以輸出的結果如上。避免的方法就是強迫加上template參數。

1
2
3
4
5
template <typename T> 
void outer(string&& value)
{
	return inner(Forward<T>(value));
}

重新執行程式，這下結果符合我們的需求了

1
2
3
4
inner(std::string &str)
inner(const std::string &str)
inner(std::string&& str)
inner(const std::string&& str)

這邊還有幾點要說明的
之前的範例，value是左值，而T可能是U&或是U，T&的結果是U&，可以繫結住左值沒有問題。萬一Forward的參數是個右值怎麼辦？

1
inner(Forward<T>(string()));

我們需要另外一個function，解決function resolution的問題。

1
2
3
4
5
template <typename T>
T&& Forward(T&& value)
{
	return static_cast<T&&>(value);
}

在傳進來的是個右值時，T被推導成U。T&&正好可以綁定一個Rvalue，解決上面的問題。不過問題又來了，如果是左值的話，T是U&，T&是U&，T&&還是U&，變成兩個function擁有兩個一模一樣的參數型態，Compiler不知道該選哪個。
解決方案就是套用上面Move所引進的RemoveReference，還原成Primitive Type。

1
2
3
4
5
6
7
8
9
10
template <typename T>
T&& Forward(typename RemoveReference<T>::type& value)
{
	return static_cast<T&&>(value);
}
template <typename T>
T&& Forward(typename RemoveReference<T>::type&& value)
{
	return static_cast<T&&>(value);
}

這樣子有另外一個好處，這個方案禁止了型別推導，不會再有Forward(value)的存在，編譯時期就能指出錯誤。

Posted on Edited on

C++0x引進了Lambda Expression，這功能其實也不新鮮了，在其他語言都有類似的觀念。
為了處理Callback function，做了很多的改進
同樣的，我們從C語言時期看起。

C時期

C語言只有一種方式處理callback function，function pointer。
像這個樣子

1
2
3
4
5
6
int add2(int a, int b) { return a + b; }
int operate(int a, int b, op2 func)
{
        return func(a, b);
}
operate(3, 2, add2);

Function Pointer的方式處理Callback function非常經典，幾乎可以在所有純C語言開發的程式碼看到他。不過還是有可以改進的地方，例如

  • 速度: 由於傳進來的是指標，只能間接呼叫，無法有足夠的資訊做最佳化。
  • 狀態: Function比較難保存運行中的特定狀態。

C++98時期

C++的Functor(仿凾式)就是因此而生的，透過overload operator()，來改進上述所無法缺憾。搭配template的使用，使其應用更具彈性。可以同時支援Callback function跟Functor兩種形式。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
struct Add2 {
	int operator()(int a, int b) 
	{
		return a + b;
	}
};
int sub2(int a, int b) { return a - b; }
template <typename T>
int operate(int a, int b, T callback)
{
	return callback(a, b);
}
operate(3, 2, Add2());
operate(3, 2, sub2);

之後有人想要將class member method跟static class method也包裝成Functor的形式，有Loki跟Boost兩大主流為主。這裡就不多談了，在C++0x中也將boost的bind跟function列入TR1裡，可以很方便的產生Functor。

C++0x時期

Functor雖好，不過每要新增一個新功能，就要寫一個function object，如果是只被使用一次的functor，維護這段程式碼需要付出成本，
因此就產生了一個暱名函數(anonymous function)，像這樣。

1
2
3
4
5
6
7
8
for_each(v.begin(), v.end(), [](int n) {
	cout << n;
	if (n % 2 == 0) {
		cout << " even ";
	} else {
		cout << " odd ";
    }
});

詳細的語言規範可以參考MSDN的資料。透過跟程式碼上下文互動，達到非常有趣的效果。

Lambda Trick

之前我們介紹過unique_ptr，用來管理動態記憶體，非memory的Resource該怎麼處理，此時就是ScopeGuard登場的時候

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
class ScopeGuard
{
public:
    explicit ScopeGuard(std::function<void()> onExitScope) 
        : onExitScope_(onExitScope), dismissed_(false)
    { }

    ~ScopeGuard()
    {
        if(!dismissed_)
        {
            onExitScope_();
        }
    }

    void Dismiss()
    {
        dismissed_ = true;
    }

private:
    std::function<void()> onExitScope_;
    bool dismissed_;

private: // noncopyable
    ScopeGuard(ScopeGuard const&);
    ScopeGuard& operator=(ScopeGuard const&);
};
int main()
{
	HANDLE h = CreateFile(...);
	ScopeGuard onExit([&] { CloseHandle(h); });
	// do smoething 
	return 0;
}

或者將不同function signature，由於要經過相同的處理流程，於是用lambda expression隱藏了細節，以下是DirectX ToolKit的部分程式碼。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
template<typename T, typename TCreateFunc>
static T* DemandCreate(Microsoft::WRL::ComPtr<T>& comPtr, TCreateFunc createFunc)
{
	T* result = comPtr.Get();

    if (!result)
    {
        // Create the new object.
        ThrowIfFailed(
        	createFunc(&result)
        );
        comPtr.Attach(result);
    }
    return result;
}
ID3D11SamplerState* CommonStates::LinearClamp() const
{
    return DemandCreate(pImpl->linearClamp, [&](ID3D11SamplerState** pResult)
    {
        return pImpl->CreateSamplerState(D3D11_FILTER_MIN_MAG_MIP_LINEAR, D3D11_TEXTURE_ADDRESS_CLAMP, pResult);
    });
}
ID3D11DepthStencilState* CommonStates::DepthRead() const
{
    return DemandCreate(pImpl->depthRead, [&](ID3D11DepthStencilState** pResult)
    {
        return pImpl->CreateDepthStencilState(true, false, pResult);
    });
}

可以看得出來，DemandCreate處理的流程相同，但是船進去的type跟Callback function不同，就能達到一般化的效果，這也是我目前看到最有趣的例子。

Posted on Edited on

C語言時期

在C語言中，最常遇到的情況就是忘了釋放記憶體，然後造成Memory Leak的問題。
例如以下這段程式

1
2
3
4
5
6
7
8
9
10
11
void LeakDemo(char path1, char path2)
{
	void *alloc = malloc(16);
	if (path1) {
		free(alloc);
		return;
	}
	if (path2) return;
	free(alloc);
	return;
}

在上面這段程式裡面，path2就忘了釋放記憶體，然後造成Leak。
這是語言上的侷限，只能靠多檢查source code跟使用工具來減少這種問題。

C++98時期

由於C++有RAII idiom之後，對於釋放記憶體的事情就變得簡單很多了。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
struct StackObject {
	void *alloc;
	StackObject(int size) {
		alloc = malloc(size);
	}
	~StackObject() {
		free(alloc);
	}
};
void NoLeakDemo(char path1, char path2)
{
	StackObject s(16);
	if (path1) return;
	if (path2) return;
	return;
}

而為了一般化，STL裡面時做了一個auto_ptr，利用Template跟RAII的觀念來管理記憶體。

auto_ptr的問題

如果把auto_ptr侷限於上面的用法，不會遇上什麼問題，一旦要搭配現有的程式碼，當參數傳來傳去，問題就出現了其中最嚴重的問題莫過於

1
2
3
4
5
6
7
void Test(auto_ptr<int> v) {}
int main()
{
        auto_ptr<int> v(new int(4));
        Test(v);
        printf("%d\n", *v);
}

以上的程式碼，看起來沒什麼問題，不過實際執行就Crash了。
auto_ptr的問題是沒有Copy Semantics，他的Copy Constructur裡面做的是Move的動作。
以下是auto_ptr的Conpy Constructor實作簡化版

1
2
3
4
5
6
7
8
9
10
11
12
13
template <typename _Tp>
class auto_ptr {
private:
	_Tp* _M_ptr;
public:
	auto_ptr(auto_ptr& __a) throw() : _M_ptr(__a.release()) {}
	_Tp* release() throw()
	{
		element_type* __tmp = _M_ptr;
		_M_ptr = 0;
		return __tmp;
	}
};

於是在執行完Test之後，main中的v裡面的pointer就被清空，無法正常使用。
由於這個緣故，STL的各種容器跟演算法，搭配上auto_ptr或多或少都有問題。在經過多次修改之後還是無法修復，於是auto_ptr在C++0x之後就標繼承deprecated了，不建議使用。
由於C++0x引進了Rvalue reference，因此新的unique_ptr就此登場。

unique_ptr

unique_ptr能做的事幾乎跟auto_ptr一樣，除了少數例外。

1
2
3
4
auto_ptr<int> a(new int);
auto_ptr<int> b(a); // Compile success, but nosafe
unique_ptr<int> c(new int);
unique_ptr<int> d(c); // Compile error

不過你也可以利用C++0x新增的Move Semantics，手動進行Move動作。

1
2
unique_ptr<int> c(new int);
unique_ptr<int> d(std::move(c)); // OK

靠著C++0x新增的Rvalue Reference，區分出Copy跟Move的差異。看著unique_ptr的實作，他只允許Move Constructor，而不允許Copy Constructor。

1
2
3
4
5
6
7
8
9
10
template<class _Ty, class _Dx>	
class unique_ptr
{
private:
	unique_ptr(const _Myt&);				// not defined
	unique_ptr& operator=(const _Myt&);		// not defined
public:
	unique_ptr(unique_ptr&& _Right) 			_NOEXCEPT;
	unique_ptr& operator=(unique_ptr&& _Right)	_NOEXCEPT;
};

如果要得到更多的Rvalue Refenece的相關內容，請參考這篇Rvalue References: C++0x Features in VC10, Part 2。

unique_ptr還能做些什麼

由於C++0x引進了Move Semantics，連帶的STL所有Container跟Algorithmer都支援Move Semantics了，因此這樣的程式碼就變得可行了。

1
2
3
4
5
6
7
8
typedef unique_ptr<char> UniCharPtr;
vector<UniCharPtr> vc;
vc.push_back(UniCharPtr(new char('c')));
vc.push_back(UniCharPtr(new char('b')));
vc.push_back(UniCharPtr(new char('a')));
sort(vc.begin(), vc.end(), [] (const UniCharPtr &a, const UniCharPtr &b) -> bool {
	return *a < *b;
});

在這裡同樣用上了lambda expression，留待有空再寫。

有個手法稱作source and sink idiom
因為有了Move Semantics更容易的實現。

1
2
3
4
unique_ptr<int> Source() { return unique_ptr<int>(new int); }
void Sink(unique_ptr<int> s) {}
auto source = Source();
Sink(std::move(source));

除此之外，還能夠自訂Destructor。

1
2
3
4
5
auto del = [](int *p) { 
	cout << "Deleting x, value is : " << *p << endl; 
	delete p;
};
std::unique_ptr<int, decltype(del)> px(new int(5), del);

以及透過partial specialization來管理一個動態產生的Array。

1
2
auto del = [](int p[]) { delete [] p; };
std::unique_ptr<int [], decltype(del)> px(new int[5], del);

Posted on Edited on

要從一個singly lisked linerar list中刪除文件，最簡單的方式莫過於用一個指標指向前一個node，如果現在的item需要刪除，將前面一項item指向後面的item即可。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
typedef struct node  
{
    struct node * next; 
} node;  

node *remove_if(node * head, remove_fn rm)
{       
    for (node *prev = NULL, *curr = head; curr != NULL; )   
    {   
            node * next = curr->next;  
            if (rm(curr))  
            {   
                    if (prev)  
                            prev->next = curr->next;  
                    else  
                            head = curr->next;  
                    free(curr);  
            }   
            else  
                    prev = curr;  
            curr = next;  
    }   
    return head;  
}

有人提出了更精巧的方法，利用two star pointer來達成，也就是指標的指標。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
void remove_if(node **head, remove_fn rm)
{
    for (node** curr = head; *curr; )
    {
            node * entry = *curr;
            if (rm(entry))
            {
                    *curr = entry->next;
                    free(entry);
            }
            else
                    curr = &entry->next;
    }
}

在C++11的年代，增加了forward_list，省得自己造輪子的麻煩。
以下是forward_list的介紹。

std::forward_list is a container that supports fast insertion and removal of elements from anywhere in the container. Fast random access is not supported. It is implemented as singly-linked list and essentially does not have any overhead compared to its implementation in C. Compared to std::list this container provides more space efficient storage when bidirectional iteration is not needed.

以下是一個示範程式，裡面同時使用了lambda expression跟Range-based for loop，日後有時間在寫。

1
2
3
4
5
6
7
8
9
10
11
12
13
#include <iostream>
#include <forward_list>
int main()
{
    std::forward_list<int> list = {8, 7, 5, 3, 2, 6, 4};
    list.remove_if([](int n) { return n % 2 == 0; }); 

    for (int n : list) {
        std::cout << n << ' '; 
    }   
    std::cout << '\n';
}

Posted on Edited on

安裝openssh-server

1
$ apt-get install openssh-server

現在就可以用Putty從遠端登入了，如果要有更佳的安全性，需要做進一步的設定。

修改sshd_config

這個檔案位在/etc/ssh/sshd_config。

禁止root帳號login

將設定檔裡面的 PermitRootLogin yes 改成 no。

更改login port

修改Port 22。

允許特定IP登入

修改/etc/hosts.allow這個檔案

新增 sshd: xxx.xxx.xxx.xxx allow允許特定的IP放行。

拒絕所有IP登入，除了上面已經允許的部分

修改/etc/hosts.deny

新增sshd: all deny

修改設定過後，重新啟動服務

1
$ /etc/init.d/ssh (stop / start / restart)

Posted on Edited on

在Stackoverflow看到類似的問題，紀錄一下
假設我門需要把一個resource加入執行檔或Library，可以使用以下的方法
假設我們現在有個檔案，叫做data
裡面的內容還是我們的老朋友Hello world!
有兩個方式可以達成

將檔案變成 object file

1
$ objcopy -I binary -O elf64-x86-64 -B i386 data data.o

如果我們用nm來觀看其內容

1
2
3
4
$ nm data.o
000000000000000d D _binary_data_end
000000000000000d A _binary_data_size
0000000000000000 D _binary_data_start

其中的A代表在之後的連結過程，其數值不會再之後的動作所更改。接著我們寫另外一段程式

1
2
3
4
5
6
7
8
9
10
11
12
13
#include <stdio.h>

extern char my_data[] asm("_binary_data_start");
extern char my_data_size[] asm("_binary_data_size");
extern char my_data_end[] asm("_binary_data_end");

int main()
{
        char *c;
        for (c = my_data; c != my_data_end; c++) putchar(*c);
        printf("String length: %ld\n",  (long)(void *)my_data_size);
        return 0;
}

編譯且執行他

1
2
3
4
$ gcc test.c data.o -o test
$ ./test
Hello world!
String length: 13

從code可以看出，我們的my_data就是對應_binary_data_start的部分
please reference Controlling Names Used in Assembler Code

重新用nm看產生的執行檔，關切我們在意的部分

1
2
3
4
$ nm test
0000000000601035 D _binary_data_end
000000000000000d A _binary_data_size
0000000000601028 D _binary_data_start

發現_binary_data_start跟_binary_data_end在連結之後，都被重定位了。而_binary_data_size的位置保持不變，因此可以做為一個sentinel使用。

將檔案變成單一header file (適用於各種編譯器)

利用工具將Binary Data轉成Header file，這邊用linux的xxd來做示範。

1
$ xxd xxd -i data data.h

重寫我們的程式

1
2
3
4
5
6
7
8
9
10
11
nclude <stdio.h>
#include "data.h"

int main()
{
        int i;
        for (i = 0; i < data_len; i++) putchar(data[i]);
        printf("String length: %d\n",  data_len);
        return 0;
}

編譯且執行他

1
2
3
4
$ gcc test.c -o test
$ ./test
Hello world!
String length: 13

可以得到跟上面一樣的結果。