//======================================
//===========拷貝構造函數的重載=========
//======================================
//======================================
//======================================
兩個指針成員指向默認拷貝構造函數，會出現地址錯誤。
include <iostream>
using namespace std;
class A{
int date;
public:
A(int d) :date(d){
cout << "A(int)"<< endl;
}
A(char d) :date(d){
cout << "A(char)"<< endl;
}
A(bool d) :date(d ? 123:345){
、cout << "A(bool)"<< endl;
}
A(int& d) :date(d){
cout << "A(int&)"<< endl;
}
A(const A& o) :date(o.date){
cout << "A(const &)"<< endl;
}
/* A(const A o) :date(o.date){
cout << "A(const &)"<< endl;
}
*///將引用去掉，這樣行不行。。不行！為什么？引用是用來初始化變量的別名。傳入的數據進行初始化，非引用會將實參復制一部分給形參，此時的形參是新變量，由實參進行初始化
//如果沒有引用，A a2(a1),調用A（A o）. A o (a1)..相當于反復的創建a1，因此不行。（創建對象時，要調用構造函數。調用構造函數時，又要創建形參，而形參是新的對象，而創建新對象有要調用構造函數，調用構造函數需要形參，這樣反反復復編譯器編譯不能成功）
virtual ~A(){
cout <<"~A()" <<endl; //一個類中存在一個析構函數
}
void show()const {
cout << "date="<< date<<endl;
}
};
void show(A obj)
{
obj.show(); //拷貝構造函數的使用
}
void func(const A& obj)
{
obj.show(); //注意傳入參數為常量，因此在類中的show函數中，需要定義為常量
}
int main(int argc,char argv[])
{
//A a1(3);
show('v'); //調用類外的show函數，并定義A obj為char 類型的字符串。。用過之后直接析構掉了。。
show(23);
A a1(3);
show(a1);
//A a2(true);
//A& a3 = a1;
//a3.show();
//show(a3);
//A a4(a1); //這個是采用A（const A& o ）
//A a5('V');
//A a6();
cout <<"======func========" << endl;
func(a1); //因為使用引用，因此在已經有a1的情況下，不會再創建新對象
}
/*
//動態數組類，可變長短的數組。。
include <iostream>
include <string>
using namespace std;
class A{
char* p; //因為是動態數組，不能直接定義數組。
int len;
public:
A(int n) : len(0),p(NULL) { //構造函數，設置n個數組長度
resize(n);
}
void resize(int n){ //作用，將數組長度調整為指定長度
char* q = new char[n]; //新傳入數組，設定長度
int min = ( n< len? n:len );
if(p!=NULL)
{
for(int i=0; i< min; i++)
{ //p指向的數據全部轉移到q指向的空間
q[i] = p[i];
}
delete []p;
p = q;
for(i = min; i<n; i++)
p[i] = '\0';
}
len = n;
}
void set(int index,char value)
{
if(index>0)
p[index] = value;
}
char get(int index){
return p[index];
}
~A(){
if(p!=NULL){
delete[] p;
}
}
A (const A& o): len(o.len){
p = new char [len];
for(int i=0; i<len; i++)
p[i] = o.p[i];
} //拷貝構造函數，此算法是深拷貝
};
int main()
{
A a1(10);
a
}
//此方法是淺顯的拷貝
*/
include <iostream>
using namespace std;
class Array{
char* p;
int len;
public:
Array(int n) : len(n),p(new char[n]){}
int size(){
return len;
}
~Array(){
delete []p;
}
void fill(char start,int skip)
{
for(int i = 0;i<len ;i++)
p[i]=start +i*skip;
}
void show(){
for(int i=0; i< len; i++ )
cout << p[i];
cout << endl;
}
Array(const Array& o) :len(o.len){
p = new char [len];
for(int i=0; i<len; i++)
p[i] = o.p[i];
}
};
int main()
{
Array a1(10);
a1.fill('a',1);
a1.show();
Array a2(a1);
a2.fill('A',1);
a2.show();
a1.show();
}
