|
#
摘要: 溫故而知新，總結了多種單例模式的寫法，考慮上多線程沒有非常完美的，各取所需吧
//1.//Easy ,<<Pattern Design>>//Q://When to free the m_singleton space?//when to execute the ... 閱讀全文
總用到這個轉化，記下來
 wchar_t* atow(char* src)
   {
 int dest_len;
dest_len = MultiByteToWideChar(CP_ACP,0,src,-1,NULL,0);
wchar_t *dest = new wchar_t[dest_len];
if(dest == NULL)
return NULL;
MultiByteToWideChar(CP_ACP,0,src,-1,dest,dest_len);
return dest;
 }
static關鍵字在C和C++中的用法稍有區別，主要是C++擴展了static關鍵字的作用
當定義一個命名空間時，可以忽略這個命名空間的名稱： namespce { char c; int i; double d; } 編譯器在內部會為這個命名空間生成一個唯一的名字，而且還會為這個匿名的命名空間生成一條using指令。所以上面的代碼在效果上等同于： namespace __UNIQUE_NAME_ { char c; int i; double d; } using namespace __UNIQUE_NAME_; 在匿名命名空間中聲明的名稱也將被編譯器轉換，與編譯器為這個匿名命名空間生成的唯一內部名稱(即這里的__UNIQUE_NAME_)綁定在一起。還有一點很重要，就是這些名稱具有internal鏈接屬性，這和聲明為static的全局名稱的鏈接屬性是相同的，即名稱的作用域被限制在當前文件中，無法通過在另外的文件中使用extern聲明來進行鏈接。如果不提倡使用全局static聲明一個名稱擁有internal鏈接屬性，則匿名命名空間可以作為一種更好的達到相同效果的方法。 注意:命名空間都是具有external 連接屬性的,只是匿名的命名空間產生的__UNIQUE_NAME__在別的文件中無法得到,這個唯一的名字是不可見的. C++ 新的標準中提倡使用匿名命名空間,而不推薦使用static,因為static用在不同的地方,涵義不同,容易造成混淆.另外,static不能修飾class
原文地址：http://www.cnblogs.com/ly4cn/archive/2005/11/28/286185.html
指針，在C/C++語言中一直是很受寵的；幾乎找不到一個不使用指針的C/C++應用。用于存儲數據和程序的地址，這是指針的基本功能。用于指向整型數，用整數指針(int*)；指向浮點數用浮點數指針(float*)；指向結構，用對應的結構指針(struct
xxx *)；指向任意地址，用無類型指針(void*)。 有時候，我們需要一些通用的指針。在C語言當中，(void*)
可以代表一切；但是在C++中，我們還有一些比較特殊的指針，無法用(void*)來表示。事實上，在C++中，想找到一個通用的指針，特別是通用的函數指針簡直是一個“不可能任務”。
C++是一種靜態類型的語言，類型安全在C++中舉足輕重。在C語言中，你可以用void*來指向一切；但在C++中，void*并不能指向一切，就算能，也失去了類型安全的意義了。類型安全往往能幫我們找出程序中潛在的一些BUG。
下面我們來探討一下，C++中如何存儲各種類型數據的指針。 1. 數據指針
數據指針分為兩種：常規數據指針和成員數據指針 1.1 常規數據指針
這個不用說明了，和C語言一樣，定義、賦值是很簡單明了的。常見的有：int*, double* 等等。 如：
int value = 123;
int * pn = &value;
1.2
成員數據指針 有如下的結構：
struct MyStruct
{
int key;
int value;
};
現在有一個結構對象:
MyStruct me;
MyStruct* pMe =
&me;
我們需要 value 成員的地址，我們可以：
int * pValue = &me.value;
//或
int * pValue
= &pMe->value;
當然了，這個指針仍然是屬于第一種范籌----常規數據指針。
好了，我們現在需要一種指針，它指向MyStruct中的任一數據成員，那么它應該是這樣的子：
int MyStruct::* pMV = &MyStruct::value;
//或
int MyStruct::* pMK = &MyStruct::key;
這種指針的用途是用于取得結構成員在結構內的地址。我們可以通過該指針來訪問成員數據：
int value = pMe->*pMV; // 取得pMe的value成員數據。
int key
= me.*pMK; // 取得me的key成員數據。
那么，在什么場合下會使用到成員數據指針呢？
確實，成員指針本來就不是一種很常用的指針。不過，在某些時候還是很有用處的。我們先來看看下面的一個函數：
int sum(MyStruct* objs, int MyStruct::* pm, int count)
{
int result = 0;
for(int i = 0; i < count; ++i)
result += objs[i].*pm;
return result;
}
這個函數的功能是什么，你能看明白嗎？它的功能就是，給定count個MyStruct結構的指針，計算出給定成員數據的總和。有點拗口對吧？看看下面的程序，你也許就明白了：
MyStruct me[10] =
{
{1,2},{3,4},{5,6},{7,8},{9,10},{11,12},{13,14},{15,16},{17,18},{19,20}
};
int sum_value = sum(me, &MyStruct::value, 10);
//計算10個MyStruct結構的value成員的總和： sum_value 值 為 110 (2+4+6+8+ +20)
int sum_key = sum(me, &MyStruct::key, 10);
//計算10個MyStruct結構的key成員的總和： sum_key 值 為 100 (1+3+5+7++19)
也許，你覺得用常規指針也可以做到，而且更易懂。Ok，沒問題：
int sum(MyStruct* objs, int count)
{
int result = 0;
for(int i = 0; i < count; ++i)
result += objs[i].value;
return result;
}
你是想這么做嗎？但這么做，你只能計算value，如果要算key的話，你要多寫一個函數。有多少個成員需要計算的話，你就要寫多少個函數，多麻煩啊。
對于拷貝構造函數引用傳遞，似乎司空見慣，認為理所當然。但是被問起這個問題，的確是一片茫然，為什么呢？ 去網上搜索了一下，的確有很多這方面的知識講解。 我們先看一下CSDN上的一個帖子的回答： 簡單的回答是為了防止遞歸引用。 具體一些可以這么講： 當一個對象需要以值方式傳遞時，編譯器會生成代碼調用它的拷貝構造函數以生成一個復本。如果類A的拷貝構造函數是以值方式傳遞一個類A對象作為參數的話，當需要調用類A的拷貝構造函數時，需要以值方式傳進一個A的對象作為實參； 而以值方式傳遞需要調用類A的拷貝構造函數；結果就是調用類A的拷貝構造函數導致又一次調用類A的拷貝構造函數，這就是一個無限遞歸。 這個解釋還是蠻具體的。 利用值傳遞的話，會導致遞歸引用。 還有一片文章也談到了這個問題，
我覺得寫得也非常好！ 為什么拷貝構造函數必須為引用傳遞，不能是值傳遞？ 鏈接地址： http://www.cnblogs.com/chio/archive/2007/09/14/893299.html其中講到了3個問題 1是拷貝構造函數的作用。
作用就是用來復制對象的，在使用這個對象的實例來初始化這個對象的一個新的實例。 2是參數傳遞過程到底發生了什么？
將地址傳遞和值傳遞統一起來，歸根結底還是傳遞的是"值"(地址也是值，只不過通過它可以找到另一個值)！ i)值傳遞: 對于內置數據類型的傳遞時，直接賦值拷貝給形參(注意形參是函數內局部變量)；
對于類類型的傳遞時，需要首先調用該類的拷貝構造函數來初始化形參(局部對象)；如void foo(class_type obj_local){},
如果調用foo(obj); 首先class_type
obj_local(obj) ,這樣就定義了局部變量obj_local供函數內部使用 ii)引用傳遞: 無論對內置類型還是類類型，傳遞引用或指針最終都是傳遞的地址值！而地址總是指針類型(屬于簡單類型),
顯然參數傳遞時，按簡單類型的賦值拷貝，而不會有拷貝構造函數的調用(對于類類型). 3是在類中有指針數據成員時，拷貝構造函數的使用？
如果不顯式聲明拷貝構造函數的時候，編譯器也會生成一個默認的拷貝構造函數，而且在一般的情況下運行的也很好。但是在遇到類有指針數據成員時就出現問題了：因為默認的拷貝構造函數是按成員拷貝構造，這導致了兩個不同的指針(如ptr1=ptr2)指向了相同的內存。當一個實例銷毀時，調用析構函數free(ptr1)釋放了這段內存，那么剩下的一個實例的指針ptr2就無效了，在被銷毀的時候free(ptr2)就會出現錯誤了,
這相當于重復釋放一塊內存兩次。這種情況必須顯式聲明并實現自己的拷貝構造函數，來為新的實例的指針分配新的內存。 問題1和2回答了為什么拷貝構造函數使用值傳遞會產生無限遞歸調用的問題； 問題3回答了回答了在類中有指針數據成員時，拷貝構造函數使用值傳遞等于白顯式定義了拷貝構造函數，因為默認的拷貝構造函數就是這么干的
一 拷貝構造函數是C++最基礎的概念之一，大家自認為對拷貝構造函數了解么？請大家先回答一下三個問題:
1. 以下函數哪個是拷貝構造函數,為什么?
- X::X(const X&);
- X::X(X);
- X::X(X&, int a=1);
- X::X(X&, int a=1, b=2);
2. 一個類中可以存在多于一個的拷貝構造函數嗎?
3. 寫出以下程序段的輸出結果, 并說明為什么?
如果你都能回答無誤的話，那么你已經對拷貝構造函數有了相當的了解。
- #include
- #include
-
- struct X {
- template<typename T>
- X( T& ) { std::cout << "This is ctor." << std::endl; }
-
- template<typename T>
- X& operator=( T& ) { std::cout << "This is ctor." << std::endl; }
- };
-
- void main() {
- X a(5);
- X b(10.5);
- X c = a;
- c = b;
- }
解答如下：
1. 對于一個類X,如果一個構造函數的第一個參數是下列之一:
a)
X&
b) const X&
c) volatile X&
d) const
volatile X&
且沒有其他參數或其他參數都有默認值,那么這個函數是拷貝構造函數.
- X::X(const X&);
- X::X(X&, int=1);
2.類中可以存在超過一個拷貝構造函數,
- class X {
- public:
- X(const X&);
- X(X&);
- };
注意,如果一個類中只存在一個參數為X&的拷貝構造函數,那么就不能使用const
X或volatile X的對象實行拷貝初始化.
- class X {
- public:
- X();
- X(X&);
- };
-
- const X cx;
- X x = cx;
如果一個類中沒有定義拷貝構造函數,那么編譯器會自動產生一個默認的拷貝構造函數.
這個默認的參數可能為X::X(const X&)或X::X(X&),由編譯器根據上下文決定選擇哪一個.
默認拷貝構造函數的行為如下:
默認的拷貝構造函數執行的順序與其他用戶定義的構造函數相同,執行先父類后子類的構造.
拷貝構造函數對類中每一個數據成員執行成員拷貝(memberwise
Copy)的動作.
a)如果數據成員為某一個類的實例,那么調用此類的拷貝構造函數.
b)如果數據成員是一個數組,對數組的每一個執行按位拷貝.
c)如果數據成員是一個數量,如int,double,那么調用系統內建的賦值運算符對其進行賦值.
3. 拷貝構造函數不能由成員函數模版生成.
- struct X {
- template<typename T>
- X( const T& );
-
- template<typename T>
- operator=( const T& );
- };
-
原因很簡單, 成員函數模版并不改變語言的規則,而語言的規則說,如果程序需要一個拷貝構造函數而你沒有聲明它,那么編譯器會為你自動生成一個.
所以成員函數模版并不會阻止編譯器生成拷貝構造函數, 賦值運算符重載也遵循同樣的規則.(參見Effective C++ 3edition,
Item45)
二
針對上面作者的討論，理解更深了，但是下面我還是會給出一個一般的標準的實現和注意事項：
#include "stdafx.h"
#include "stdio.h"
#include <iostream>
#include <string>
struct Test1
{
  Test1() { }
Test1(int i) { id = i; }
Test1(const Test1& test)
{
id = test.id;
 }
Test1& operator = (const Test1& test)
{
if(this == &test)
return *this;
id = test.id;
return *this;
}
int id;
};
class Test2
{
public:
Test2(){ m_pChar = NULL;}
Test2(char *pChar) { m_pChar = pChar;}
Test2(int num)
{
m_pChar = new char[num];
for(int i = 0; i< num; ++i)
m_pChar[i] = 'a';
m_pChar[num-1] = '\0';
}
Test2(const Test2& test)
{
char *pCharT = m_pChar;
m_pChar = new char[strlen(test.m_pChar)];
strcpy(m_pChar, test.m_pChar);
if(!pCharT)
delete []pCharT;
}
Test2& operator = (const Test2& test)
{
if(this == &test)
return *this;
char *pCharT = m_pChar;
m_pChar = new char[strlen(test.m_pChar)];
strcpy(m_pChar, test.m_pChar);
if(!pCharT)
delete []pCharT;
return *this;
}
private:
char *m_pChar;
};
int main(int argc, char* argv[])
{
const Test1 ts(1); // Test1()
const Test1* p_ts = &ts;
const Test1 ts2(ts); //Test(const Test1& test)
const Test1 ts3 = ts; //Test(const Test1& test)
Test1 ts4; ts4 = ts; //Test1& operator = (const Test1& test)
Test2 t(5);
Test2 t2(t);
Test2 t3 = t2;
Test2 t4; t4 = t;
return 0;
}
TAG:預編譯和宏定義,VC++,VC++的預編譯功能
TEXT:
這里介紹VC6的預編譯功能的使用，由于預編譯詳細使用比較的復雜，這里只介紹幾個最重要的預編譯指令: /Yu,
/Yc,/Yx,/Fp。其它的詳細資料可以參考： MSDN -> Visual Studio 6.0 Document -> Visual C++
6.0 Document -> VC++ Programmer Guider - >Compiler and Linker ->
Details -> Creating Precompiled Header files
預編譯頭的概念：
所謂的預編譯頭就是把一個工程中的那一部分代碼，預先編譯好放在一個文件里（通常是以.pch為擴展名的），這個文件就稱為預編譯頭文件這些預先編譯好的代碼可以是任何的C/C++代碼，甚至是inline的函數，但是必須是穩定的，在工程開發的過程中不會被經常改變。如果這些代碼被修改，則需要重新編譯生成預編譯頭文件。注意生成預編譯頭文件是很耗時間的。同時你得注意預編譯頭文件通常很大，通常有6-
7M大。注意及時清理那些沒有用的預編譯頭文件。
也許你會問：現在的編譯器都有Time
stamp的功能，編譯器在編譯整個工程的時候，它只會編譯那些經過修改的文件，而不會去編譯那些從上次編譯過，到現在沒有被修改過的文件。那么為什么還要預編譯頭文件呢？答案在這里，我們知道編譯器是以文件為單位編譯的，一個文件經過修改后，會重新編譯整個文件，當然在這個文件里包含的所有頭文件中的東西（.eg
Macro, Preprocessor ）都要重新處理一遍。
VC的預編譯頭文件保存的正是這部分信息。以避免每次都要重新處理這些頭文件。
根據上文介紹，預編譯頭文件的作用當然就是提高便宜速度了，有了它你沒有必要每次都編譯那些不需要經常改變的代碼。編譯性能當然就提高了。
要使用預編譯頭，我們必須指定一個頭文件，這個頭文件包含我們不會經常改變的代碼和其他的頭文件，然后我們用這個頭文件來生成一個預編譯頭文件（.pch文件）想必大家都知道
StdAfx.h這個文件。很多人都認為這是VC提供的一個“系統級別”的，編譯器帶的一個頭文件。其實不是的，這個文件可以是任何名字的。我們來考察一個典型的由AppWizard生成的MFC
Dialog
Based 程序的預編譯頭文件。（因為AppWizard會為我們指定好如何使用預編譯頭文件，默認的是StdAfx.h，這是VC起的名字）。我們會發現這個頭文件里包含了以下的頭文件：
#include <afxwin.h> // MFC core and standard
components
#include <afxext.h> // MFC extensions
#include <afxdisp.h> // MFC Automation classes
#include <afxdtctl.h> // MFC support for Internet Explorer
4 Common Controls
#include <afxcmn.h>
這些正是使用MFC的必須包含的頭文件，當然我們不太可能在我們的工程中修改這些頭文件的，所以說他們是穩定的。
那么我們如何指定它來生成預編譯頭文件。我們知道一個頭文件是不能編譯的。所以我們還需要一個cpp文件來生成.pch
文件。這個文件默認的就是StdAfx.cpp。在這個文件里只有一句代碼就是：#include“Stdafx.h”。原因是理所當然的，我們僅僅是要它能夠編譯而已―――也就是說，要的只是它的.cpp的擴展名。我們可以用/Yc編譯開關來指定StdAfx.cpp來生成一個.pch文件，通過/Fp編譯開關來指定生成的pch文件的名字。打開project
- >Setting->C/C++ 對話框。把Category指向Precompiled
Header。在左邊的樹形視圖里選擇整個工程，Project Options(右下角的那個白的地方)可以看到 /Fp
“debug/PCH.pch”，這就是指定生成的.pch文件的名字，默認的通常是 <工程名>.pch。然后，在左邊的樹形視圖里選擇StdAfx.cpp，這時原來的Project
Option變成了 Source File Option（原來是工程，現在是一個文件，當然變了）。在這里我們可以看到
/Yc開關，/Yc的作用就是指定這個文件來創建一個Pch文件。/Yc后面的文件名是那個包含了穩定代碼的頭文件，一個工程里只能有一個文件的可以有YC開關。VC就根據這個選項把
StdAfx.cpp編譯成一個Obj文件和一個PCH文件。
這樣，我們就設置好了預編譯頭文件。也就是說，我們可以使用預編譯頭功能了。以下是注意事項：
1）如果使用了/Yu，就是說使用了預編譯，我們在每個.cpp文件的最開頭，包含你指定產生pch文件的.h文件（默認是stdafx.h）不然就會有問題。如果你沒有包含這個文件，就告訴你Unexpected
file end.
2）如果你把pch文件不小心丟了，根據以上的分析，你只要讓編譯器生成一個pch文件就可以了。也就是說把
stdafx.cpp（即指定/Yc的那個cpp文件）重新編譯一遍就可以了。
|