]]>
首先來看一個例子：
int main(int argc, char* argv[])
{
const int i=0;
int *j = (int *) &i;
*j=1;
cout<<&i<<endlcout<<j<<endl;
cout<<i<<endl;
cout<<*j<<endl;
return 0;
}
結果是
0012ff7c
0012ff7c
0
1
因為i和j都指向相同的內存地址，所以輸出的前兩個結果是相同的，但為啥相同的內存里的結果不相同么？－－這就是常量折疊.
這個"常量折疊"是 就是在編譯器進行語法分析的時候，將常量表達式計算求值，并用求得的值來替換表達式，放入常量表。可以算作一種編譯優化。
我只是改了這個地址內容,但是i還是0,
因為編譯器在優化的過程中，會把碰見的const全部以內容替換掉（跟宏似的: #define pi 3.1415,用到pi時就用3.1415代替），這個出現在預編譯階段；但是在運行階段，它的內存里存的東西確實改變了!!!
6.網上的一些問題（4）
關于常量
這些天被常量的一些概念折磨著,現在終于有些明白了，
問題始于const int i = 10;//i存在哪，10存在哪
說明一：符號表
這個語句是對i的聲明，因為編譯器一開始就知道i的值，所以以后出現i時就會用10代替，這好像叫做符號表的概念，i就對應10了。
網上一篇帖子上有這樣的代碼：
const int a = 3;
int *p = const_cast<int *>(&a);
*p = 4;
cout << a;//仍然輸出3
這個結果可以用上面的說明來解釋
說明二：常量折疊（const folding）與復寫傳播 (copy propagation)
網上人們普遍反映thinking in c++將const folding譯為常量折疊是種誤導，我覺得譯的還行，本來folding就有折疊的意思，就是把原來的東西變小，而象const int i = 2*2;編譯器確實將2*2算成4了，以后碰到i就用4替換，這個計算2*2的過程據說叫常量折疊--const folding，而用4替換i的過程叫做復寫傳播--copy propagation.他們都是編譯器的優化技術
說明三：為常量分配空間
補充一下，這里說的都是const 定義的常量，而非文字常量，
（c++ primer翻譯成文字常量--literal constant
the c++ programming language（tcpl）翻譯成文字量，還分了不同類型）
至于文字常量存在哪，c++ primer 3ed上說它們是不可尋址的--nonaddressable，盡管它們也存在機器內存某個地方，但無法訪問它們的地址
對于int double等類型還好理解，但是對于字符串常量（tcpl里說將字符串文字量作為常量，利于存儲與訪問時的優化）下面的代碼似乎表示字符串常量存儲在靜態存儲區里（字符串文字量是靜態分配的--tcpl），那么字符串常量的地址不是可以訪問了嗎，在靜態存儲區里
http://bbs.bc-cn.net/dispbbs.asp?boardid=56&replyi...
字符串文字量的類型是常量字符數組--適當個數的const字符的數組
//有關字符常量的存儲區的問題
//另外，char a[]和char *a的區別
//"hello world 1"存在哪
#include <iostream>
using namespace std;
int main()
{
char* p = "hello world1"；
char a[] = "hello world2"；
//會為a在棧上分配13個字節的空間
// p[2] = a;
a[2] = a;
char* p1 = "hello world1"
printf("%xn",&p[2]);//p應該指向常量區
printf("%x",&a[2]);//棧上數組第三個元素的地址
return 0;
//結果42f036 //這是常量區
//12ff6e果然不一樣，這是棧區
}
6.總結
那么"常量折疊"到底是啥意思呢？
我理解，簡單的說就是，當編譯器處理const的時候，編譯器會將其變成一個立即數。
《thinking in c++》里面說這一點在數組定義里尤其重要(為啥呢？沒有查到相關的資料)。
]]>
版本：0.1
最后修改：2010-11-22
撰寫：李現民
概述
const在c++中意味著“不可改變”，但在有些情況下我們可以“合法”地繞過編譯器去修改一些const數據，比如const_cast就可以剝離一個對象的const屬性。然而，我們這樣做在多大程度上是“合理”的，卻因不同的問題而論，也許一不小心，你就可能掉入陷阱之中。
以下問題，我只分析，不說話，請各位看官自己判斷。
當目標是一個常數
這件事源于在網上看到的一篇文章，其來源已經不可考，但大意是：就如下C++程序，其輸出是什么：
void
foo()
{
const
int
a =
1;
int*
p =
const_cast<int*>(&a);
*p =
2;
printf("
a= %d\n *p= %d\n &a= %x\n p= %x \n\n",
a,
*p,
&a,
p);
}
我在VC2008下的實測結果為：
a = 1
*p = 2
&a = 12ff6c
p = 12ff6c
好了，問題出現：明明p所指向的就是變量a，但為何打印其值時a!=*p？
這并非是我用錯了const_cast，也不是編譯器進行了優化的問題。事實上，在各版本的VC與g++下的運行結果均是如此。
以下是VC2008下debug版本的匯編代碼：
const
int a = 1;
0041146E
mov dword ptr [a],1
int*
p = const_cast<int*>(&a);
00411475
lea eax,[a]
00411478
mov dword ptr [p],eax
*p =
2;
0041147B
mov eax,dword ptr [p]
0041147E
mov dword ptr [eax],2
printf("
a= %d\n *p= %d\n &a= %x\n p= %x \n\n", a, *p, &a, p);
00411484
mov esi,esp
00411486
mov eax,dword ptr [p]
00411489
push eax
0041148A
lea ecx,[a]
0041148D
push ecx
0041148E
mov edx,dword ptr [p]
00411491
mov eax,dword ptr [edx]
00411493
push eax
00411494
push 1
00411496
push offset string " a=\t%d\n *p=\t%d\n &a=\t%x\n
p=\t%x \n\n"... (415808h)
0041149B
call dword ptr [__imp__printf (419318h)]
從printf()的四個參數入棧過程中我們可以看出：指針p的確指向變量a了，而變量a處的數值也的確被改寫成2了，問題是：當壓入a的值的時候，編譯器直接壓入了其原始數值1。
關鍵其實在于：const_cast所操作的目標是否為基礎數據類型（char, int, float, double等），如果是類（或結構體）對象則又將是另一番情形。
當修改字符串常量
這個問題最早見于一篇文章《Solmyr的小品文系列之一：字符串放在哪里？》，在這里我只不過轉述一二。
代碼如下：
void
foo()
{
char*
str1 =
"watch";
const
char*
str2 =
"watch";
char
str3[] =
"watch";
str1[0] =
'm';
std::cout<<
str1
<< std::endl
<< str2
<< std::endl
<< str3
<< std::endl;
}
VC6中Release版本運行結果如下：
match
match
watch
VC2008中Release版本運行結果如下：
watch
watch
watch
容易看出：這段代碼的運行結果決定于編譯器，因為我們改寫了不應該被改寫的常量數據。更根本的原因是：由于編譯器優化，str1與str2實際上指向的是同一份”watch”字符串。
這還帶出了另一件事：盡管str1的聲明中不帶const，但它所指向的字符串數據隱含是const類型的。
注意：這段代碼只有Release版本才能順利執行，Debug版版本運行時會得到一個Access violation 。
]]>
delete this--對象請求自殺
版本：0.1
最后修改：2009-08-18
撰寫：李現民
第一次見delete this的時候，沒覺得這是一項會有什么特殊作用的技術，因此也就沒有特別關注。
昨日在sourcemaking.com上看state模式之c++實現的時候，看到它在狀態轉換的時候使用了delete this，感覺似乎還不錯。
作為一種“禁術”，使用的時候必須要相當小心才行，《C++ FAQ》里提到所謂“小心”至少包括以下幾個方面：
-
this對象是必須是用 new操作符分配的（而不是用new[]，也不是用placement new，也不是局部對象，也不是global對象）；
-
delete this后，不能訪問該對象任何的成員變量及虛函數（delete this回收的是數據，這包括對象的數據成員以及vtable，不包括函數代碼）；
-
delete this后，不能再訪問this指針。換句話說，你不能去檢查它、將它和其他指針比較、和 NULL比較、打印它、轉換它，以及其它的任何事情；
個人認為保證以上禁忌列表基本手段可以包括：
-
將析構函數私有化（如果有子類，則protected化，保證子類能夠正確繼承）--以保證對象必須使用new在堆上分配內存；
-
提供（可以在僅僅在基類中）Destroy(void)函數，里面僅有一句delete this--以保證第三方能夠將分配的內存回收；
下一次使用state pattern的時候，我想可以嘗試一下。
]]>
如果 unsigned int a; ，那么，你無法通過測試 if(a>0)測試出你賦給a的值到底是否是正的，因此，通常我們寧愿使用 int b; 配合 assert(a>=0);
不過，由于項目的需要（基于windows的，使用了太多的DWORD，不過DWORD的定義通常為unsigned long），其中還是使用了一些unsigned int，我發現項目中通常要求賦一個很大（最大）的初始值，用什么？ 0xffffffff嘛？ 我都記不住0x后面應該有幾個f，況且，我不能保證系統一定是32位的；
還是用 unsigned int a= -1;吧，就讓無符號整數為自己也做點貢獻吧。
]]>
D:\me\document\VC6\test\test.cpp(34) : error C2146: syntax error : missing ',' before identifier 'test_map'
D:\me\document\VC6\test\test.cpp(34) : error C2065: 'test_map' : undeclared identifier
D:\me\document\VC6\test\test.cpp(34) : error C2143: syntax error : missing '>' before ';'
于是改寫成如下代碼：
typedef std::vector<int> IntVector;
typedef std::map<int, IntVector> IntVectorMap;
IntVectorMap test_map;
順利編譯通過 -_- 還真是邪門了。
注：std::map<int, std::vector<int>> test_map; 在vs2005下順利編譯通過。
]]>
factory.hpp
#pragma warning (disable:4786)
/********************************************************************
created: 2008-10-22
author: lixianmin
purpose: a generic factory method lib
reference: 《C++對話系列--Abstract Factory, Template Style》
Copyright (C) 2008 - All Rights Reserved
*********************************************************************/
#include <string>
#include <map>
namespace lib
{
//通用工廠類，根據傳入的id創建產品對象
template <typename BaseType, typename KeyType=std::string>
class factory
{
private:
typedef std::auto_ptr<BaseType> (*BaseCreateFunc)();
typedef std::map<KeyType, BaseCreateFunc> FuncRegistry;
public:
static factory<BaseType, KeyType>& get_instance() //static singleton，不適用于多線程
{
static factory<BaseType, KeyType> obj;
return obj;
}
std::auto_ptr<BaseType> create(const KeyType& id) const
{
std::auto_ptr<BaseType> obj;
FuncRegistry::const_iterator regEntry = _registry.find(id);
if (regEntry != _registry.end())
{
obj = regEntry->second();
}
return obj;
}
void _register_create_function(const KeyType& id, BaseCreateFunc func){_registry[id] = func;}
private:
factory(void){}
factory(const factory& other);
factory operator=(const factory& other);
private:
FuncRegistry _registry;
};
//類型(DerivedType)注冊類，只要在DerivedType類定義(DerivedType.cpp文件)的最后聲明一個 lib::factory_register<Base, Derived> reg(id);對象即可
template <typename BaseType, typename DerivedType, typename KeyType=std::string>
class factory_register
{
public:
factory_register(const KeyType& id)
{
factory<BaseType, KeyType>::get_instance()._register_create_function(id, _create_instance);
}
private:
static std::auto_ptr<BaseType> _create_instance(){return std::auto_ptr<BaseType>(new DerivedType);}
private:
friend class factory<BaseType, KeyType>;
};
}
#include "factory.hpp"
//基類
class Base
{
public:
virtual void print(void)
{
std::cout<<"base class"<<std::endl;
}
};
lib::factory_register<Base, Base> reg1("base"); //注冊Base類型，定義一個file scope的變量，通常應該置于Base.cpp文件結尾
//派生類
class Derived:public Base
{
public:
virtual void print(void)
{
std::cout<<"derived class"<<std::endl;
}
};
lib::factory_register<Base, Derived> reg2("derived"); //注冊Derived類型，定義一個file scope的變量，通常應該置于Derived.cpp文件結尾
//聲明一個全局函數（簡化操作，非必需）
lib::factory<Base>& glb_GetFactory(void)
{
return lib::factory<Base>::get_instance();
}
int main(int argc, char* argv[])
{
std::auto_ptr<Base> base=glb_GetFactory().create("base");
if (base.get())
{
base->print();
}
std::auto_ptr<Base> derived=glb_GetFactory().create("derived");
if (derived.get())
{
derived->print();
}
system("pause");
return 0;
}
base class
derived class
請按任意鍵繼續. . .
]]>
3、定義數組時，使用向量：std::vector<char> vBuffer(nSize)，而不要使用 char* a=new char[nSize];這樣可以讓容器替你維護這段內存；如果數組大小固定且應用簡單的話也可以使用固定長度的數組， 如char text[nSize];
4、很多教程都在談std::auto_ptr的好處，但在我的經驗中必須使用std::auto_ptr的地方很少，我只見過兩種：一是factory method返回動態對象指針時，為了保證內存釋放最好使用智能指針封裝；二是加載特別大的資源對象時，這種對象由于太大而不適合放在stack中；
5、使用傳引用方式傳參pass-by-reference(-to-const)，避免使用傳指針pass-by-pointer的方式，這樣既可以免去指針判NULL的檢查，又可以在不失去對象所有權的前提下傳遞std::auto_ptr<...> 對象
]]>
#include <sys/stat.h>
int main(int argc, char* argv[])
{
const char* szPath="c:\\abc.txt";
if (_access(szPath, 0)) //測試文件是否存在，如果測試為真，則文件不存在
{
std::cout<<szPath<<"--does not exist!"<<std::endl;
return -1;
}
struct stat st;
stat(szPath, &st);
std::cout<<"file size="<<st.st_size<<std::endl; //獲取文件屬性(包括大小、創建時間、宿主等等)
system("pause");
return 0;
}
]]>
]]>
狀態檢測的必要性在于：代碼的擴大(復雜化)，新人參與的維護及狀態的更迭隨時有可能在出人意料的情況下調用到某些函數，這些函數可能在大多數情況下在這里調用是有意義的，但在某些極端的情況下卻可能造成數據破壞，因此在各函數入口處執行完善的狀態檢測是很有意義的。
針對各種狀態可以維護一個對應的bool值，但寫一個enum附帶一個status數組可能更容易維護：
{
stLoaded, //數據加載完畢
stRecording, //數據錄制中
stReplaying, //數據回放中
stSize //狀態數組的大小
};
bool m_aStatus[stSize];
]]>
可是，這樣的函數是inline的嘛？在定義式那邊加上inline?待進一步探索
]]>
]]>
情形一：如果類Country類是你本人設計的，即你擁有對Country類的修改權，那么在類中重載operator<就可以了，需要注意的就是必須將其設計為const成員函數，如下：
{
public:
explicit Country(int population)
{
m_nPopulation=population;
}
void print()
{
std::cout<<m_nPopulation<<std::endl;
}
//注：operator<必須是const成員函數
bool operator<(const Country& b)const
{
return m_nPopulation<b.m_nPopulation;
}
private:
int m_nPopulation;
};
int main(int argc, char* argv[])
{
Country countryArray[]={Country(43), Country(54),Country(85),Country(95),Country(12),Country(57),Country(124),Country(78),
Country(45), Country(56),Country(87),Country(457),Country(567),Country(123),Country(456),Country(237),
Country(43), Country(784),Country(728),Country(76),Country(467),Country(83),Country(723),Country(86)};
std::set<Country> countrySet;
int nSize=sizeof countryArray/ sizeof countryArray[0];
for (int i=0; i<nSize; ++i)
{
countrySet.insert(countryArray[i]);
}
for (std::set<Country>::iterator iter=countrySet.begin(); countrySet.end()!=iter; ++iter)
{
iter->print();
}
//Sleep(int(2e9));
system("pause");
return 0;
}
情形二：Country為不是你設計的，即類中沒有已存在的operator<比較器，同時你也無法對其進行修改，那么你現在需要做的是在外部設計一個比較器，確切的說，是一個函數對象（或函數，但函數無法內聯），如下：
{
public:
explicit Country(int population)
{
m_nPopulation=population;
}
void print()
{
std::cout<<m_nPopulation<<std::endl;
}
//比上一個設計需要新加入一個函數
int GetPopulation(void) const
{
return m_nPopulation;
}
private:
int m_nPopulation;
};
int main(int argc, char* argv[])
{
Country countryArray[]={Country(43), Country(54),Country(85),Country(95),Country(12),Country(57),Country(124),Country(78),
Country(45), Country(56),Country(87),Country(457),Country(567),Country(123),Country(456),Country(237),
Country(43), Country(784),Country(728),Country(76),Country(467),Country(83),Country(723),Country(86)};
//設計函數對象
struct country_less:public std::binary_function<Country, Country, bool>
{
//這個倒不必須成為const成員函數，呵呵
bool operator()(const Country& a, const Country& b)const
{
return a.GetPopulation()<b.GetPopulation();
}
};
//std::set的定義就要復雜一些了
std::set<Country, country_less> countrySet;
int nSize=sizeof countryArray/ sizeof countryArray[0];
for (int i=0; i<nSize; ++i)
{
countrySet.insert(countryArray[i]);
}
//同樣，迭代器的定義也要復雜一些
for (std::set<Country, country_less>::iterator iter=countrySet.begin(); countrySet.end()!=iter; ++iter)
{
iter->print();
}
//Sleep(int(2e9));
system("pause");
return 0;
}
這兩種情況的作用就是std::less<>謂詞，因此同樣適用于std::sort()
]]>
公司原先的代碼參差不齊，有使用AString的（使用ANSI char作為字符單元，相當于std::string），也有考慮到unicode問題而采用AWString的（使用wchar_t作為字符單元，相當于std::wstring），同時考慮到根據編譯環境自動視別的問題，也定義有一個宏ACString，即：如果定義有UNICODE環境變量，則自動替換為AWString，否則使用AString。好吧，自作聰明的我使用了ACString來寫工具函數，測試時沒有任何問題，但一旦加入到真正的運行環境中就會出現“把const char*轉化為bool，性能警告”的錯誤，幾經檢查，發現在游戲環境下，傳入的參數是AString類型，而我用的ACString則被自動轉化成了AWString，找不到參數匹配的，所以只有默認轉化了。
看來，解決辦法只能是同時提供AString與AWString兩種類型的工具函數，因為你不知道你的客戶傳給你的將是哪一種，除非大家都鐵了心的一致使用ACString，然而在現實的編碼中，這卻是不切實際的。
這讓我想起前兩天為STL寫的格式化函數（STL沒有，只好自己寫了-_-），當時我也想自作聰明的把std::string與std::wstring合二為一，現在想來恐怕是庸人自擾罷了，于是早上起來把原來的代碼作下修改，如下：
#include <string>
#include <vector>
#include <cassert>
#ifndef __STR_STR_HPP_INCLUDED_
#define __STR_STR_HPP_INCLUDED_
namespace str
{
//字符串格式化函數
std::string format(const char *fmt,
) {
std::string strResult="";
if (NULL != fmt)
{
va_list marker = NULL;
va_start(marker, fmt); //初始化變量參數
size_t nLength = _vscprintf(fmt, marker) + 1; //獲取格式化字符串長度
std::vector<char> vBuffer(nLength, '\0'); //創建用于存儲格式化字符串的字符數組
int nWritten = _vsnprintf_s(&vBuffer[0], vBuffer.size(), nLength, fmt, marker);
if (nWritten>0)
{
strResult = &vBuffer[0];
}
va_end(marker); //重置變量參數
}
return strResult;
}
//字符串格式化函數
std::wstring format(const wchar_t *fmt,
) {
std::wstring strResult=L"";
if (NULL != fmt)
{
va_list marker = NULL;
va_start(marker, fmt); //初始化變量參數
size_t nLength = _vscwprintf(fmt, marker) + 1; //獲取格式化字符串長度
std::vector<wchar_t> vBuffer(nLength, L'\0'); //創建用于存儲格式化字符串的字符數組
int nWritten = _vsnwprintf_s(&vBuffer[0], vBuffer.size(), nLength, fmt, marker);
if (nWritten > 0)
{
strResult = &vBuffer[0];
}
va_end(marker); //重置變量參數
}
return strResult;
}
}
#endif
#include <cassert>
#include "str.hpp"
int main(int argc, char* argv[])
{
const double PI=3.1415926;
std::string s=str::format("ANSI%s---字符：%c；整數：%d；雙精度：%f", "測試",'a', 38, PI);
std::cout<<s<<std::endl;
std::wstring ws=str::format(L"UNICODE%s---字符：%c；整數：%d；雙精度：%f", L"測試",'u', 83, PI);
std::wcout<<ws<<std::endl;
system("pause");
return 0;
}
問題一：前面的format函數只能在vs2005下通過編譯，在vc6.0下就不可以，原因是
用于“獲取格式化字符串長度”的_vscprintf和_vscwprintf在vc6.0中找不到替代品；問題二：相信大家已經看到了，ANSI字符串的測試沒有任何問題，但UNICODE字符串在輸出時中斷了，確切的說是在輸出到中文時中斷了，我用斷點查看過，ws的構造沒有問題，即wchar_t版的format函數沒有問題，那么問題就應該出在std::wcout上面，但問題在哪呢？
諸位看官，歡迎提供任何指導意見。
]]>