久久久久久久久久久精品尤物,国产精品久久久久久久,国产欧美一区二区久久

簡歷——為何真實反而成敗筆？！！

近兩個月里，又開始了新的跳槽。誠然，我之前跳槽次數確實過多了，但出于在當前公司的工作內容、待遇、職稱評定等方面的不滿，最終還是下定了跳槽的決心。（當然，也對之前的求職做了回顧，畢竟我也不想再有這種頻繁的跳槽了，我也想穩定下來了。）

而在一開始，就已經有朋友勸我，在簡歷中得弄點虛假和夸張，否則很難找到好的工作。可惜，本人對這種夸大優點，剔除一切不利信息的簡歷制作實在是難以為之！最終，想而易知，我所投出的簡歷所得到的回應是少得可憐。期間，我聽說了一些通過在簡歷上的“美化”而取得求職成功的例子，也陸續的有幾個朋友勸我在簡歷上不要太老實，得做些變通，如，“將中間的某兩個公司的經歷合寫成一個公司的經歷”、“某些內容可以不要寫到簡歷上”、“某些內容應該再做些擴充，并對某些詞替換成更吸引人點的詞”等等。我也確有幾次去嘗試調整簡歷，可是，以到這弄虛假、夸張、隱瞞時，我卻又實在是下不了手。沒辦法，或許這就是本性難移吧。

還好，回應總算還是有一些，而且目前也拿到了一份還算滿意的Offer。在即將進入的新公司里，還是好好干吧！~

哎！~這可怕的求職市場啊，實在太令人心冷了！~

posted @ 2012-05-14 22:15 青碧竹閱讀(554) | 評論 (1) | 編輯收藏

Windows 控制臺程序的事件捕獲

摘要: 此篇內容屬C++控制臺編程的一點基礎應用，所以嘛，偶就偷個懶，不再做文字的講解，直接代碼。哦，對了！代碼之前，先就代碼的組成作個簡單說明。代碼的內容共分為三塊：以宏RUN_ATEXIT_SAMPLE標識的atexit調用樣例以宏RUN_SETC... 閱讀全文

posted @ 2012-04-23 00:07 青碧竹閱讀(1000) | 評論 (0) | 編輯收藏

樹中兩個結點的最低公共祖先

<本文的樣例代碼：/Files/qingbizhu/LowestCommonAncestor.zip>

這是《劍指Offer——名企面試官精講典型編程題》一書中的面試題50，此題針對所給條件的不同，將需要截然不同的解題思路和方法。書中給出了針對此題的3種不同條件的解題，本文所要講解的是對其第3種條件的一個改進解法。具體的題目及條件如下。

【題目】：

輸入兩個樹結點，求它們的最低公共祖先。

【補充條件】：

樹是普通的樹，而且樹中的結點沒有指向父節點的指針。

針對上述的題目和條件，書中給出了如下解決方案。

【原方案】：

使用兩個鏈表，對樹進行兩次遍歷以查找兩個樹結點，并保持路徑到兩個鏈表中，從而將問題轉化為求兩個鏈表的最后一個公共結點。

從該方案中，觀察到兩次樹結點查找的遍歷中，其中一個結點的遍歷過的樹結點序列將完全覆蓋查找另一結點時所遍歷的樹結點序列。由此入手，本文提出了如下的改進解決方案。

【改進方案】：

深度優先遍歷樹，并記錄路徑，當找到第一個結點后，在當前基礎上繼續遍歷搜索第二個結點，并記錄第一個結點路徑的變化程度，直到找到第二個結點。最后，根據棧信息和記錄的結點路徑變化程度得到最低公共祖先。如圖1，假設輸入的兩個樹結點為D和K，樹的根節點為R，則求D和K的最低公共結點的過程如下表：

步驟

棧

第一個結點

第二個結點

路徑變化程度

1

R

—

—

—

2

R，A

—

—

—

3

R，A，F

—

—

—

4

R，A，F，J

—

—

—

5

R，A，F，G

—

—

—

6

R，A，F，K

K

—

0（或K）

7

R，A，C

K

—

1（或A）

8

R，A，C，E

K

—

2（或A）

9

R，A，C，I

K

—

2（或A）

10

R，A，D

K

D

1（或A）

è 得出結果，最低公共祖先結點為A

從中，可以看到，改進后的方案，只需對樹執行一次遍歷。而在輔助空間的需求上，只需使用一個棧（外加少量結點指針變量和1個表示路徑變化程度的整型變量）。而且，如果采用遞歸的方式實現，該棧所需保存的信息，還可以通過遞歸時的函數調用棧得以保存。

【附注】：

此處，有如下一個問題：
假設待查找公共祖先的兩樹結點，其中一結點在以另一結點為根的子樹上（包括兩結點相同）時，公共祖先的確定規則——
“作為子樹根結點的那個結點”還是“子樹根結點的父節點”？
例如：對上面圖1中的那棵樹，如果待查結點為根結點R和結點F，那么最終的查找結果是為R呢，還是因為R是根結點無父結點而得出NULL？
此問題在書中未提及，但查看書中代碼，確認是選擇了后者；而在本人的樣例代碼中則采用了前面的觀點。
在樣例代碼中，對樹結點在棧中的存儲方式略有改動。
樣例代碼工程所使用的環境為 Visual C++ 2010；
其中：tree.h/cpp為功能代碼文件，TestLowestCommonAncestor.h/cpp為相應的UT代碼文件；
UT采用gtest所編寫，編譯鏈接請根據gtest在自己本機的路徑狀況修改gtest_link.props文件中相應的鏈接項。

posted @ 2012-04-05 23:45 青碧竹閱讀(3085) | 評論 (0) | 編輯收藏

不使用＋－×÷ 運算符來實現加減乘除四項運算

摘要: 最近，在看《劍指Offer——名企面試官精講典型編程題》一書，當看到“面試題47：不用加減乘除做加法”時，經過一分鐘左右思考后，得出了思路，跟書上一對照，基本一致，呵呵O(∩_∩)O~。于是，隨即又開始思考：加法是實現了，那么減法、乘法還有除法又該怎么實現呢？一番思考與分析后，得出算法，寫出代碼，測試通過，Happy！！\(^... 閱讀全文

posted @ 2012-03-30 01:30 青碧竹閱讀(4985) | 評論 (7) | 編輯收藏

關于數值的整數次方的計算

在計算一個浮點數（雙精度或單精度）的整數次方時，一般的，我們會直接使用 C++ 本身所提供的 pow 函數，事實上也推薦直接使用 pow 函數（為了稱呼簡便，后面稱該 pow 函數為系統 pow 函數）。

但是，當我們準備寫一個自己的 pow 時，我們又會怎么寫呢？一般的，我們會寫上一個 for 循環來循環冪的指數次，而且每次循環都會去執行一次浮點數的乘法操作。但是，當我們拿這個 pow 函數來跟系統 pow 函數作一運行比較時，就會發現，我們的 pow 實在是太低效了。那么怎么樣才能使我們自己寫的 pow 也能有系統函數那樣的時間效率呢？

仔細分析，我們用的那個求冪值的循環過程，就能發現，其實我們還是做了很多不必要的浮點數乘法炒作。整個計算過程太過按步就班了。譬如說在計算 val（待傳入pow 函數求冪的浮點數，下同）的4次方，我們總是先計算出3次方的值，然后再根據3次方的值和原始值來求4次方的值；然而，我們其實本可以在計算出2次方值后，平方2次方值來得到4次方的值的。接下來，就是探索算法，以減少浮點數乘法的事了。

通過所學的指數函數的知識，我們知道指數函數有著這樣的性質：

V^(a+b) = V^a * V^b
V^a*b = (V^a)^{b ；這里 * 為乘法運算符}

另外，對于整數，有如下性質：

2ⁿ = (1 << n) ;這里 << 是向左移位的操作符。
C++中的任何一個正整數（負整數同，但須處理好符合位）都可以表示為以下形式：
n = 2^a1+ 2^a2 + ... + 2^ak
(其中，a1, a2, ... , ak 為閉區間 [0, 30] 上的整數值，且互不相同。)

由此，我們就可以事先依次計算出 val, val², val⁴, ... , val³⁰預存備用，然后再根據 val 相應 bit 上是 1 還是 0，來選取相應的預存數據進行相乘，從而得到最終的結果。當然，合理設計邏輯，還可以減少所需的預存數據。下面是我的Pow 代碼，歡迎點評。

#define INTBITS_WITHOUT_SIGN 31 // the bit-size of type int with the sign bit being excluded.

bool IsZero(double val, double precision /*= DEFAULT_PRECISION*/)

{

if (precision >= 0) {

return (-precision <= val) && (val <= precision);

} else {

return (precision <= val) && (val <= -precision);

}

double Pow(double val, int exponent)

{

if (IsZero(val)) {

return 0.0;

}

if (0 == exponent) {

return 1.0;

}

bool bIsExponentMinus = false;

if (exponent < 0) {

exponent = -exponent;

bIsExponentMinus = true;

}

double tempVal[INTBITS_WITHOUT_SIGN];

memset(tempVal, 0, INTBITS_WITHOUT_SIGN);

tempVal[0] = val;

double result = 1.0;

int index = 0;

while (exponent != 0) {

if ((exponent & 1) != 0) {

result *= tempVal[index];

}

exponent >>= 1;

if (exponent != 0) {

tempVal[index + 1] = tempVal[index] * tempVal[index];

++index;

}

if (bIsExponentMinus) {

result = 1.0 / result;

}

return result;

}

【補充】：

1. 在指數中，0的負數次方和0的0次方，都是沒有意義的，所以對“if (IsZero(val))”分支內的處理如果能加上一些異常的輸出就更好了，如：

在Widows下，可通過 SetLastError(...) 來設置錯誤碼。

2. Pow中的 “double tempVal[INTBITS_WITHOUT_SIGN];” 一句，改寫為

double * pTempVal = new double[sizeof(int) * 8 - 1];

(當然，后面代碼中的tempVal 也都要改為相應的 pTempVal，同時須記得在return 前把delete [] pTempVal)

就可以使代碼也能夠適應于64位系統的處理。對于無符號整數的為指數的情況，則輔助值空間應為“sizeof(unsigned int) * 8”，同時，無需再考慮負指數的情況。

(這里，很感謝春秋十二月的補充。)

posted @ 2012-03-17 04:01 青碧竹閱讀(2993) | 評論 (4) | 編輯收藏

Singleton模式——C++應用（四）

摘要: 在前面的例子中，我們看到：采用 new 來為單件對象分配空間，如果采用手動調用 delete 或封裝了 delete 的 Release 操作，一旦遇到全局對象的析構有調用單件對象，就會使得無法在代碼中找到適合釋放單件對象的時機。那么，是否可以讓系統來自動選擇時機，調用釋放呢？如果可以，又該怎么在代碼中構建單件對象的自動釋放機制呢? 對這兩個問題，在進行了一番思考和嘗試后，終于找到了答... 閱讀全文

posted @ 2012-03-14 01:07 青碧竹閱讀(341) | 評論 (0) | 編輯收藏

Singleton模式——C++應用（三）

摘要: 前面對C++的Singleton模式的探討還都是針對通過靜態變量來創建對象。但學習嘛，多走點總不是壞事。接下來就來看看通過 new 來創建單件對象的單件類設計。既然是用 new 來創建了，那自然就不能忽略需要用 delete 來釋放。好了，先來看看代碼： Code highlighting produced by Actipro CodeHighlighter (freeware)htt... 閱讀全文

posted @ 2012-03-13 00:55 青碧竹閱讀(252) | 評論 (0) | 編輯收藏

Singleton模式——C++應用（二）

看了通過靜態成員實現的惰性單件，雖說構件簡單且線程安全，但在被全局變量（包括靜態全局變量）的構造或析構調用時，會存在著那樣的缺陷畢竟還是很讓人不爽。那么，是否存在保持上面的優點同時剔除了上面的缺陷的C++單件呢？

我們知道，定義于函數內部的靜態局部變量，有著

定義的實時性，即只在函數第一次被調用時才被定義
線程安全性
生命期直到程序結束

的特點。那么，通過這個局部靜態變量來創建的單件又會是什么樣呢？貼上我的Demo代碼，這就來看看吧。

1

// Singleton demo_1: Singleton instance is a local static varible of class.
2

3

#include <Windows.h>
4

#include <iostream>
5

6

class A
7

{
8

public:
9

static A& GetInstance();
10

11

private:
12

A() : m_nStat1(-1), m_nStat2(-1) {
13

m_nStat1 = 0;
14

std::cout << "Construct A" << std::endl;
15

m_nStat2 = 0;
16

}
17

A(const A&);
18

19

public:
20

~A() {
21

m_nStat1 = 0;
22

std::cout << "Destruct A" << std::endl;
23

m_nStat2 = 0;
24

}
25

26

void Do() {
27

++m_nStat1;
28

++m_nStat2;
29

std::cout << "Called Do() by object of A. ["
30

<< m_nStat1 << ", "
31

<< m_nStat2 << "]"
32

<< std::endl;
33

}
34

35

private:
36

int m_nStat1;
37

int m_nStat2;
38

};
39

40

class B
41

{
42

public:
43

B(int nID) : m_nID(nID) {
44

std::cout << "Construct B: " << m_nID << std::endl;
45

A::GetInstance().Do();
46

}
47

~B() {
48

std::cout << "Destruct B: " << m_nID << std::endl;
49

A::GetInstance().Do();
50

}
51

52

private:
53

int m_nID;
54

};
55

56

class C
57

{
58

public:
59

static C& GetInstance();
60

61

private:
62

C() : m_nStat(-1) {
63

std::cout << "Construct C" << std::endl;
64

m_nStat = 0;
65

}
66

C(const C&);
67

68

public:
69

~C() {
70

std::cout << "Destruct C" << std::endl;
71

m_nStat = 0;
72

}
73

74

void Do() {
75

++m_nStat;
76

std::cout << "Called Do() by object of C. ["
77

<< m_nStat << "]"
78

<< std::endl;
79

}
80

81

private:
82

int m_nStat;
83

};
84

85

static B gs_B0(0);
86

B g_B1(1);
87

88

A& A::GetInstance()
89

{
90

static A s_instance;
91

92

return s_instance;
93

}
94

95

C& C::GetInstance()
96

{
97

static C s_instance;
98

99

return s_instance;
100

}
101

102

static B gs_B2(2);
103

B g_B3(3);
104

105

int main(int argc, char * argv[])
106

{
107

std::cout << "Enter main" << std::endl;
108

A::GetInstance().Do();
109

C::GetInstance().Do();
110

111

system("pause");
112

return 0;
113

}
114

接下來，自然就是執行結果：

喲吼~，這不正是自己想要的結果么，Perfect！！

構建簡單，創建具有實時性（在且只在第一次用到時創建），線程安全，可以被全局變量的構造和析構正常調用，就是它了，極力推薦！O(∩_∩)O~

posted @ 2012-03-12 02:08 青碧竹閱讀(240) | 評論 (0) | 編輯收藏

Singleton模式——C++應用（一）

前天，在看了《劍指Offer》中關于Singleton模式的一段內容后，就按耐不住對其在C++上完美實現的思考。書中這一講是針對C#的實現來講解的，因為C#的垃圾回收機制，其中那些個顯眼的[new]已無需程序員去手動釋放。但是，C++上確并不存在垃圾回收機制，程序員得手動[delete] [new]出來的內容，這就有了以下兩問：

何時釋放通過new所創建的Singleton對象？
如果不通過new、malloc等操作，是否能做到在第一次使用時才創建Singleton對象。

在針對以上兩個問題做了一番思考和嘗試之后，終于有了成果。現呈現出來，供大家參考，也希望有更好妙招的朋友能不吝賜教。礙于連代碼帶文字，篇幅較長，所以我將分為四篇來講。那么，開始咯！^_^

一開始，我先拿使用靜態成員變量的來實現的惰性單件來進行嘗試，寫了個Demo，一運行，O(∩_∩)O哈哈~，還真有意外的收獲呢！嗯~，抓緊時間，先把我的Demo上來給大家瞧瞧！~

1

// Singleton demo_0: Singleton instance is a static member of class.
2

3

#include <Windows.h>
4

#include <iostream>
5

6

class A
7

{
8

private:
9

static A ms_instance;
10

11

public:
12

static A& GetInstance() {
13

return ms_instance;
14

}
15

16

private:
17

A() : m_nStat1(-1), m_nStat2(-1) {
18

m_nStat1 = 0;
19

std::cout << "Construct A" << std::endl;
20

m_nStat2 = 0;
21

}
22

A(const A&);
23

24

public:
25

~A() {
26

m_nStat1 = 0;
27

std::cout << "Destruct A" << std::endl;
28

m_nStat2 = 0;
29

}
30

31

void Do() {
32

++m_nStat1;
33

++m_nStat2;
34

std::cout << "Called Do() by object of A. ["
35

<< m_nStat1 << ", "
36

<< m_nStat2 << "]"
37

<< std::endl;
38

}
39

40

private:
41

int m_nStat1;
42

int m_nStat2;
43

};
44

45

class B
46

{
47

public:
48

B(int nID) : m_nID(nID) {
49

std::cout << "Construct B: " << m_nID << std::endl;
50

A::GetInstance().Do();
51

}
52

~B() {
53

std::cout << "Destruct B: " << m_nID << std::endl;
54

A::GetInstance().Do();
55

}
56

57

private:
58

int m_nID;
59

};
60

61

class C
62

{
63

private:
64

static C ms_instance;
65

66

public:
67

static C& GetInstance() {
68

return ms_instance;
69

}
70

71

private:
72

C() : m_nStat(-1) {
73

std::cout << "Construct C" << std::endl;
74

m_nStat = 0;
75

}
76

C(const C&);
77

78

public:
79

~C() {
80

std::cout << "Destruct C" << std::endl;
81

m_nStat = 0;
82

}
83

84

void Do() {
85

++m_nStat;
86

std::cout << "Called Do() by object of C. ["
87

<< m_nStat << "]"
88

<< std::endl;
89

}
90

91

private:
92

int m_nStat;
93

};
94

95

static B gs_B0(0);
96

B g_B1(1);
97

A A::ms_instance;
98

C C::ms_instance;
99

static B gs_B2(2);
100

B g_B3(3);
101

102

int main(int argc, char * argv[])
103

{
104

std::cout << "Enter main" << std::endl;
105

A::GetInstance().Do();
106

C::GetInstance().Do();
107

108

system("pause");
109

return 0;
110

}

為了能夠分析得細致些，Demo寫得長了點，見諒咯！~

嗯，對了，還有運行結果：

仔細看看結果，有沒覺得這結果很出乎意料啊？！！（順便提下，我用的編譯工具是Visual C++ 2010）

從這個運行結果，對通過靜態成員實現的惰性單件，我得到了以下兩點：

對于定義在單件對象之前的全局或靜態全局對象，雖然單件對象還是會在調用前及時構造，但構造函數內的初始化操作卻可能在需要使用時還未能執行完全。
如：std::cout 就會使得單件對象的構造函數調用被暫停（單件的其他操作還能繼續調用），直到單件之前的全局或靜態全局的構造函數全執行完了，才能繼續執行。【*這個原因還請有知道的高手能賜教。】
對于定義于單件對象之后的全局或靜態全局對象，如果在析構中調用了單件，就會使得單件在釋放后又被再次重新創建使用。當然，這時單件內所存的數據已跟之前毫無關聯了。

因此，我要奉勸各位開發者，如果在你的全局或靜態全局對象的構造或析構方法中調用某個單件，那么對該單件的實現就不要以靜態成員來惰性地實現。

posted @ 2012-03-12 02:04 青碧竹閱讀(289) | 評論 (0) | 編輯收藏

C++之竹

導航

留言簿

隨筆分類

隨筆檔案

閱讀排行榜

評論排行榜

常用鏈接

統計

最新評論