java基础改学C++（七）类的进一步学习
一、构造方法
观察：
class A{
float x,y;
public:
//构造1：构造函数可以指定参数的缺省值
A(float a,float b=1){ x=a; y=b; }
//构造2: 无参
A() { x=0; y=0; }
void Print(void) {cout<<x<<'\t'<<y<<endl; }
};
int main(void){
A a1, a2, a3(3.0, 7.0);
a1.Print();
a2.Print();
a3.Print();
}
2、这个写法是错的： A(float a=1,float b){ x=a; y=b; } 第一个参数不能有默认值（规定）
3、全局对象，在main函数执行之前调用构造函数
4、域不赋默认值 则是随机值，java是0或者false···
读个程序：
发现，两次调用f（）；只有一个静态A存在，不是覆盖上的，而是根本没调用第二次构造.和java一样，
一个方法不论被调几次，其内部的静态变量都是初始化1次，并在全局实例析构之前析构
再说一遍。。。new 运算符：返回地址 用new运算符产生的动态对象，在不再使用这个对象时，必须用delete运算符来释放对象所占用的存储空间
demo:
class A{
public:
int x,y;
//this指针之前没说，就是java的this
A(int x,int y){this->x = x;this->y = y;}
void printx();
//一种初始化方法：
A(int a,int b,int c):x(a),y(b+c){
//当需要初始化的数据成员较多时,这种方式更显其优越性.
}
//可以在这声明一个函数头，体在下面
A();
//析构函数：函数名与类名相同，前面加上字符 ~ 不能有参数、返回值，不指定函数类型，和构造方法一样 也 有默认的析构函数
//一个类中，只能定义一个析构函数，析构函数不允许重载，回收对象时由系统自动调用
～A(){
cout<<"a instance deinit";//方法体可以写类外，像构造方法一样
}
（一般地，）调用析构函数的次序正好与调用构造函数的次序相反。
};
A::A(){
cout<<"NO para"<<endl;
}
void A::printx(){
cout<<x<<endl;
}
int main(){
A*a;
a = newA(10,10);
A a2(10,10,10);
A*b = & a2;
a->printx();
b->printx();
delete a;
// 用new的必须delete，不new的不能delete
// 直接定义的变量是定义在栈里，随着函数的弹栈而释放
// new出的东西定义在堆里，需要手动释放,系统不能回收new分配的动态存储空间
//引用变量，下面的 a45:
A & a45 = a2;
// 注意：指针用->，引用用 .
a45.printx();
//C++与java相比，多了个指针，引用也是有的。声明格式： className & varietyName = instance
}
再看一个demo学习：
class Str{
char *Sp; int Length;
public:
Str(char *string){
if(string){
Length=strlen(string);
Sp=newchar[Length+1]; //在构造函数中将成员数据指针指向动态开辟的内存
strcpy(Sp,string); //用初值为开辟的内存赋值
}else
Sp=0;
}
void Show(){
cout<<Sp<<endl;
}
~Str(){
if(Sp)
delete []Sp; //析构函数，当释放对象时收回用new开辟的空间
}
};
对象如果用new运算符开辟了空间，则在类中应该定义一个析构函数，并在析构函数中使用delete删除由new分配的内存空间
int main(){
Str s1("Study C++");
s1.Show();
}
下面是附加的一个例子，不要求理解，因为要知道内存的细节，这里不解释了
class A{
public:
int x,y;
A(int x,int y):x(x),y(y){
cout<<"an A instance init "<< endl;
}
~A(){
cout<<"an instance deinit"<<endl;
}
void printx();
};
void A::printx(){
cout<<x<<endl;
}
class B{
public:
int x,y;
B(int x,int y):x(x),y(y){
cout<<2<<"a B instance init"<<endl;
}
~B(){
cout<<"an instance deinit"<<endl;
}
void printx();
};
void B::printx(){
cout<<x<<endl;
}
int main(){
A*a =new A(10,20);
delete a;
a->printx();
((B*)a)->printx();
自己跑起来看看，打印：
an A instance init
an instance deinit
10
10
神奇的内存==
}
先说到这 以后再补充 最近有别的事