宜宾网站建设公司

(六)深入函数-创新互联

普通函数的重载(六)深入函数 
跟java没区别 都是同样的方法名,不同的参数。

缺省参数的函数

成都创新互联专注于孝昌企业网站建设,响应式网站开发,商城网站开发。孝昌网站建设公司,为孝昌等地区提供建站服务。全流程定制网站开发，专业设计，全程项目跟踪，成都创新互联专业和态度为您提供的服务
#include 
using namespace std;
class A{
public:
　　void set(int =30,int=5);
　　void count(bool=false);
private:
　　int w;
　　int h;
};
void A::set(int width,int height){
　　w=width;
　　h=height;
}
void A::count(bool val){
　　if(val==true){
　　　　cout<<"val的值为真时:"<　　}else{
　　　　cout<<"val的值为假时:"<　　}
}
int main(){
　　A a;
　　a.set();
　　a.count();
}
c++中可以写这种缺省的函数,java中应该是不可以,我个人没写过,也没有见别人写过,时间有限就不写demo测试了,有兴趣的可以试下。
不过似乎c++中这种默认的方法必须 不是内联函数才行,也就是声明跟方法分开写。

成员变量初始化

c++中有一种特殊类的成员变量初始化的写法
例:
class rectangle{
public:
　　rectangle():length(3),width(5){}
private:
　　const int length;
　　const int width;
}
在构造函数的右边有个冒号 (:),然后是成员变量的名称和一对小括号(),小括号中是要初始化的值或者表达式,如果对多个成员进行初始化,那么就要用逗号将它们隔开,最后是一对大
括号{},大括号中就是函数所要执行的功能。
这种方式是对成员变量的初始化,而 rectangle(){length=3;}这种方式是对成员进行赋值,当成员有const修饰符 是常量时，赋值的方式就会报错。
对于像常量和引用只能被初始化,不能被赋值.我们最好在构造函数的函数头中对常量和引用进行初始化。

复制构造函数

class A{
public :
　　A(){}
　　A(A&one){n=one.n;m=one.m;}//这是复制构造函数,系统默认就有的,我们可以复写也可以不管,在引用一节有关于这个的测试。
　　A(int i,int j){n=i;m=j;}
　　void print(){
　　　　cout<　　}
private:
　　int n;
　　int m;
}
int main(){
　　A a(2,4);
　　a.print();
　　cout<<"
";
　　A b(a);
　　return 0;
}

构造函数与new运算符

在c++中创建实力对象，是通过指针来引向内存空间的。
A *a;
a=new A;
a->set(3,4);
而java中 是 A a=new A();

explicit关键字

class A{
public:
　　explicit A(int x){i=x;cout<<"构造函数执行!"<　　~A(){cout<<"析构函数执行！"<　　void get(){cout<private:
　　int i;
};
int main(){
　　A a(99);
　　a.get();
　　a=1000; //对于c++来说 这句话相当于 a=A(1000);会自动调用默认构造函数,当加上explicit关键字时,就不会进行隐式转换了。
　　return;
}

复制构造函数

编译器提供了默认构造函数和析构函数,同样也提供了复制构造函数,编译器提供的默认复制构造函数只是把传递进来的对象的每个成员变量复制到新对象的成员变量中去,然后两个对象中
的变量均指向存放类成员变量的那块内存区域.加入该变量不是指针变量一般不会立即出错,加入该变量是指针变量,如图:(图片插入总失败 我就简单的表示下吧)

　　对象a　　　　　　　　　　　　-->堆<--　　　　　　复制的对象b
　　指针变量x　　　　　　　　　　　　6　　　　　　　　指针成员变量x

现在对象a 有一个指针成员变量x，它指向堆中存放6的那块内存区域,我们将对象a复制到对象b，如: A b=(a); 由于要复制对象,因此自动调用默认复制构造函数,调用的过程为为:
首先将对象a作为参数传递到默认复制构造函数中,然后将对象a的指针成员变量x复制到对象b中,这样两个对象的指针x现在都指向同一内存区域。
这样当这两个对象中的任何一个超出作用域时,都会出现致命的错误。比如说我们将对象a删除,那么析构函数会自动释放堆中存放6的那块内存空间,而对象b的指针变量x扔指向该空间,
由于该空间已经不在,那么对象b的指针变量x现在就变成了一个迷途指针,该程序面临崩溃的边缘。
为了解决浅层复制导致的迷途指针问题,我们必须创建自己的复制构造函数,并且在函数里为我们的成员变量分配内存,这样,在分配完内存后,旧对象的成员变量就可以复制到新的内存区域
中,两个对象的成员变量都各自拥有自己的内存区域,一个对象在析构后不再会影响到另一个,我们把这种复制方式叫做深层复制。例：
class A{
public:
　　A(){x=new int;*x=5;}
　　~A(){delete x;x=NULL;}
　　//定义一个深层的复制构造函数
　　A(const A&a){//因为在这个函数体中不会修改别名a所引用的原始对象的值.所以将别名a定义为别名常量。这样加入我们试图修改传递进来的对象,程序就会报错。
　　　　cout<<"复制构造函数执行...
"<　　　　x=new int;//用复制构造函数创建的新对象的指针成员x来指向它。这样两个对象的x指针都指向了不同的内存空间。
　　　　*x=*(a.x);//先通过对象a调用x指针成员后,再通过"*"读取x指针指向的空间处的值。
　　}
　　void print()const{cout<<*x<　　void set(int i){*x=i;}
private:
　　int *x;
}


当前题目：(六)深入函数-创新互联
文章链接：http://ybzwz.com/article/jeoeg.html

其他资讯