#include <sstream>
stringstream ss;
int data=200;
int result;
ss<<data;//將data轉成字串插入ss
ss>>result;//將ss的內容輸出到result
stringstream ss;
string name="Tom";
ss<<"Hello "<<name<<endl;
cout<<ss.str();\\output: Hello Tom
#include <ext/hash_map>
#include <ext/hashtable.h>
#include <map>
using namespace __gnu_cxx;
...
hash_map<string,string> maps;
maps["左邊"]="老王";
maps["右邊"]="老李";
//他會很像
hash_map<int,string> maps2;
maps2[0]="老王";
maps2[1]="老李";
...
string [] maps;
template<class _Key, class _Tp, class _HashFn = hash<_Key>,
class _EqualKey = equal_to<_Key>, class _Alloc = allocator<_Tp>>
maps[key]=value;
這裡做個小訂正，EqualFun並不是非寫不可 2009/05/06
參考資料：http://www.stlchina.org/twiki/bin/view.pl/Main/STLDetailHashMap
class Word: public Token {
public:
string lexeme;
Word(string s,int tag);
virtual ~Word();
string getData()const;
static const Word AND;
static const Word OR;
static const Word EQ;
static const Word NE;
static const Word LE;
static const Word GE;
static const Word MINUS;
static const Word TRUE;
static const Word FALSE;
static const Word TEMP;
};
struct hash_word{
size_t operator()(const string& w)const{
return __stl_hash_string(w.c_str());
}
};
struct eq_word{
bool operator()(const string& w1,const string& w2)const{
return true;
}
};
......
hash_map<string,const Word*,hash_word,eq_word> words;
words["Hello"]=new Word("s",254);
hash_word hashFun;
size_t hashkey=hashFun("Hello");
const* Word[] words;
void Lexer::readch() {
int i=getchar();
if(i!=-1)
{peek=(char)i;}
else
{throw exception();}
}
>./scan < Test1.txt
class Parent{
virtual void say(){
cout<<"I am Parent" ;
}
};
class Children:public Parent{
virtual void say(){
cout<<"I am Children" ;
}
};
.....
int main(){
Parent p=Children();
p.say();
}
I am Parent
int main(){
Parent* p=new Children();
p.say();
}
virtual void f() = 0;virtual void f(){}\\在此只是不實作
class Test{};
int main{
cout<<"sizeof(Test)" ;
}
\\Output：1 原生空類別會佔掉1byte空間
class Test{
int data;
void f(){}
};
int main{
cout<<"sizeof(Test)" ;
}
\\Output：4 有member會依據member而決定size 在此一般函式不佔class的空間
class Test{
int data;
virtual void f(){}
};
int main{
cout<<"sizeof(Test)" ;
}
\\Output：8 f變成虛擬函式，變成一個指標而多佔了4byte
void f(){
int i;\\nont-static location variable in stack
static int l;\\static location variable in .data
}
void f(){
int* pa=new int;
}
void f(){
int i;\\nont-static location variable in stack
static int l;\\static location variable in .data
}
//Test1.cpp
static int a;
int b;
void main(){
}
Test2.cpp
static int a;
static int c;
void main(){
}
A a;
a.get();
main:main.o A.o
g++ -ggdb -o main main.o A.o
main.o:main.cpp
g++ -ggdb -c main.cpp
A.o:A.cpp
g++ -ggdb -c A.cpp
main:main.o A.o
g++ -ggdb -o main main.o A.o
main.o:main.cpp A.h
g++ -ggdb -c main.cpp
A.o:A.cpp
g++ -ggdb -c A.cpp
netsh interface ip set address name="區域連線" source=static addr=xxx.xxx.xxx.xxx mask=xxx.xxx.xxx.0 gateway=xxx.xxx.xxx.xxx gwmetric=1
pause
class Parent{
Parent(){
cout<<"建構parent"<<endl;
}
~Parent(){
cout<<"解構parent"<<endl;
}
};
class Member{
Member(){
cout<<"建構Member"<<endl;
}
~Member(){
cout<<"解構Member"<<endl;
}
};
class My:public Parent{
Member m;
My(){
cout<<"建構My"<<endl;
}
~My(){
cout<<"解構My"<<endl;
}
};
void main()
{
My m;
}
建構parent
建構Member
建構My
解構My
解構Member
解構parent
void f(int);\\call by value
void f(int*);\\call by address
void f(int&);\\call by reference
main(){
f(123); \\1
f(NULL); \\2
f(0); \\3
}
void f(int& p){}
main(){
int i=0;
f(i);
}
int& p=i;
void f(int& p){}
main(){
f(123);
}
int& p=100;
int i=10;
int &r=i;
int &r;
int &r=100;
int i=10;
int &r=i;
int i=10;
int *r=&i;
int i=10;
int &r=i;
char a[3][4]={"abc","bcd","cde"};
char (*str)[4]=a;
char[4]* str;
int* str=(int*)a; \\int 也是4個byte
char *str[4]
int a[3][4]={};\\正常用法 沒問題
int b[][4]={};\\這也可以通過編譯
int c[3][]={};\\這不行
int d[][]={}\\這也不行
int a[][7][8];
int arr[2][3]={1,2,3,4};
for(int i=0;i<2;i++)
{
for(int j=0;j<3;j++)
{
cout<<arr[i][j]<<" ";
}
cout<<endl;
}
1 2 3
4 0 0
int arr[2][3]={{1,2},3,4};
for(int i=0;i<2;i++)
{
for(int j=0;j<3;j++)
{
cout<<arr[i][j]<<" ";
}
cout<<endl;
}
1 2 0
3 4 0
int arr[2][3]={{1},2,3,4};
for(int i=0;i<2;i++)
{
for(int j=0;j<3;j++)
{
cout<<arr[i][j]<<" ";
}
cout<<endl;
}
1 0 0
2 3 4
int arr[2][3]={{1},{2,3,4}};
for(int i=0;i<2;i++)
{
for(int j=0;j<3;j++)
{
cout<<arr[i][j]<<" ";
}
cout<<endl;
}
1 0 0
2 3 4
int arr[2][3]={{1},{2},3,4};
for(int i=0;i<2;i++)
{
for(int j=0;j<3;j++)
{
cout<<arr[i][j]<<" ";
}
cout<<endl;
}
int* a[10];
int b[100];
a[0]=&b[0];
a[1]=&b[10];
......
#include
#include "time.h"
main(){
clock_t prev=clock();
doSomething();
cout<<(double)(clock()-prev)/CLK_TCK;//X
}
#include
#include "time.h"
main(){
clock_t prev=clock();
doSomething();
cout<<(double)(clock()-prev)/CLOCKS_PER_SEC;//O
}
int x;
main(){
int x;
}
main(){
int x;
double x;//X
}
int x;
main(){
int x=10;
::x=20;
cout<<"區域變數x:"<<x<<endl;
cout<<"全域變數x:"<<::x<<endl;
}
區域變數x:10
全域變數x:20
class T{
T();
T(int);
T(T&);
}
T t;
t=100;
t=100;t=new T(100);
class G;
class T{
T(G&)
}
void print(T&){}
main(){
print(new G());
}
class T{
private:
int data;
public:
void op()const{}
};
void op()const{data=0;}
void op()const{dp(data);gp();}\\X
void dp(int data){}
void gp(){}
void op()const{dp(data);}
void dp(const int& data)const{} \\告訴compiler你不會修改到data
void gp()const{}
int* op()const{return &data;}const int* op()const{return &data;}
class T{
....
void dp();
}
void get(T& t){}
main(){
const T tester;
tester.dp();\\ X
get(tester);\\X
}
class T{
....
void dp()const; \\我不會更改成員
}
void get(const T& t){}\\我不會更改成員
main(){
const T tester;
tester.dp();
get(tester);
}
mutable int data;return const_cast(data)
a. const對象只能訪問const成員函數,而非const對象可以訪問任意的成員函數,包括const成員函數.
b. const對象的成員是不可修改的,然而const對象通過指針維護的對象卻是可以修改的.
c. const成員函數不可以修改對象的數據,不管對象是否具有const性質.它在編譯時,以是否修改成員數據為依據,進行檢查.
e. 然而加上mutable修飾符的數據成員,對於任何情況下通過任何手段都可修改,自然此時的const成員函數是可以修改它的
class T { // "unlimited precision int"
public:
T& operator++(); // prefix
const T operator++(int); // postfix
};
T a,b,c;
(a+b)=c;
\\or 防止
(a+b)+c;
void add(Card c);void add(Card& c);void add(const Card& c);void add(const Card& c){c=new Card;}\\X
void add(const Card& c){test(c);}
void test(Card& c){}
void test(const Card& c){}\\告訴compiler test不會修改c
\\or
void test(Card c){}\\不共用記憶體 但是失去意義
Card* add(const Card& c){return &c;}\\X
Card* a=add(c);
a.x=XXX;
const Card* add(const Card& c){return &c;}
const Card* a=add(c);
const Card add();
const int* i; (1)
int const* i; (2)
int* const i; (3)
int* i; (4)
const int*const i; (5)
*i=3; //X
i=new int; //O
i=new int;\\X*i=100;\\O
const i;
int arr[10];
int* const arr=new int[10];
