65,196
社区成员
发帖
与我相关
我的任务
分享简单的构造函数，不明白
#include<iostream.h>
#include<string.h>
class B
{
public:
B()
{
cout<<"Default Constructor\n";
}
B(char *s,double n)
{
strcpy(name,s);
b=n;
cout<<"Constructor\n";
}
~B()
{
cout<<"Destructor"<<" " <<name<<endl;
}
void getb(char*s,double&n)
{
strcpy(s,name);
n=b;
}
private:
char name[80];
double b;
};
////////////////////////////////////////////////////
void main()
{
B*p;
double n;
char s[80];
p=new B[3];
p[0]=B("ma",4.8);//这里为虾米还会去调用的析构函数啊，是不是有一个临时对象啊？
p[1]=B("wang",3.6);
p[2]=B("li",3.1);
cout << "##############" << endl;
for(int i=0;i<3;i++)
{
p[i].getb(s,n);
cout<<s<<","<<n<<endl;
}
delete[] p;
}
#include<string.h>
class B
{
public:
B()
{
cout<<"Default Constructor\n";
}
B(char *s,double n)
{
strcpy(name,s);
b=n;
cout<<"Constructor\n";
}
~B()
{
cout<<"Destructor"<<" " <<name<<endl;
}
void getb(char*s,double&n)
{
strcpy(s,name);
n=b;
}
private:
char name[80];
double b;
};
////////////////////////////////////////////////////
void main()
{
B*p;
double n;
char s[80];
p=new B[3];
p[0]=B("ma",4.8);//这里为虾米还会去调用的析构函数啊，是不是有一个临时对象啊？
p[1]=B("wang",3.6);
p[2]=B("li",3.1);
cout << "##############" << endl;
for(int i=0;i<3;i++)
{
p[i].getb(s,n);
cout<<s<<","<<n<<endl;
}
delete[] p;
}
...全文
请发表友善的回复…
发表回复
wklucky 2005-12-04
- 打赏
- 举报
mark
qinhaichao 2005-12-02
- 打赏
- 举报
析构函数应该释放内存空间吧？
Johnny_de 2005-12-02
- 打赏
- 举报
这有什么问题？
aimt 2005-12-02
- 打赏
- 举报
说得有道理,临时对象的暂存与释放,有这么一个过程.
yleiou 2005-12-02
- 打赏
- 举报
mark
pcplayboy 2005-12-02
- 打赏
- 举报
改改 只创建3个对象
int main()
{
B *p[3];
double n;
char s[80];
int i;
p[0]=new B("ma",4.8);
p[1]=new B("wang",3.6);
p[2]=new B("li",3.1);
cout << "##############" << endl;
for(i=0;i<3;i++)
{
p[i]->getb(s,n);
cout<<s<<","<<n<<endl;
}
for(i=0;i<3;i++) delete p[i];
return 0;
}
int main()
{
B *p[3];
double n;
char s[80];
int i;
p[0]=new B("ma",4.8);
p[1]=new B("wang",3.6);
p[2]=new B("li",3.1);
cout << "##############" << endl;
for(i=0;i<3;i++)
{
p[i]->getb(s,n);
cout<<s<<","<<n<<endl;
}
for(i=0;i<3;i++) delete p[i];
return 0;
}
yeqcai 2005-12-02
- 打赏
- 举报
同意楼上的说法，
new 与 delete 一起用的
new 与 delete 一起用的
ericqxg007 2005-12-02
- 打赏
- 举报
同意 Zark(金陵五月)的说法
其实在语句 p=new B[3]的时候已经调用了默认构造函数创建了3个B对象
而在对 p[0]=B("ma",4.8);
p[1]=B("wang",3.6);
p[2]=B("li",3.1);
中 又调用了B的构造函数创建了3个临时对象，在执行完每一句的时候临时变量析构函数被调用， 你可能会问为什么p[0]～p[2]为什么还能指向有效的对象， 这个是因为系统会自动重载＝号 所以原来在语句 p=new B[3]中的三个对象的私有成员分别被在上面3条语句的对象的相应私有成员赋值 ，这样你输入p数组的内容时就是 上面3条语句中临时对象的值～
其实在语句 p=new B[3]的时候已经调用了默认构造函数创建了3个B对象
而在对 p[0]=B("ma",4.8);
p[1]=B("wang",3.6);
p[2]=B("li",3.1);
中 又调用了B的构造函数创建了3个临时对象，在执行完每一句的时候临时变量析构函数被调用， 你可能会问为什么p[0]～p[2]为什么还能指向有效的对象， 这个是因为系统会自动重载＝号 所以原来在语句 p=new B[3]中的三个对象的私有成员分别被在上面3条语句的对象的相应私有成员赋值 ，这样你输入p数组的内容时就是 上面3条语句中临时对象的值～
sankt 2005-12-02
- 打赏
- 举报
#include<iostream>
#include<cstring>
using namespace std;
class B
{
public:
B()
{
cout<<"Default Constructor\n";
}
B(char *s,double n)
{
strcpy(name,s);
b=n;
cout<<"Constructor\n";
}
B(const B&other)
{
strcpy(name,other.name);
b=other.b;
cout<<"Copy constructor."<<endl;
}
B& operator=(const B& other)
{
if(this!=&other)
{
strcpy(name,other.name);
b=other.b;
}
cout<<"Operator constructor."<<endl;
return *this;
}
~B()
{
cout<<"Destructor"<<" " <<name<<endl;
}
void getb(char*s,double&n)
{
strcpy(s,name);
n=b;
}
private:
char name[80];
double b;
};
////////////////////////////////////////////////////
int main()
{
B*p;
double n;
char s[80];
p=new B[3];
p[0]=B("ma",4.8);//这里会调用构造函数和赋值构造函数，有临时对象产生
p[1]=B("wang",3.6);
p[2]=B("li",3.1);
cout << "##############" << endl;
for(int i=0;i<3;i++)
{
p[i].getb(s,n);
cout<<s<<","<<n<<endl;
}
delete []p;
system("pause");
return 0;
}
//把3个构造函数写完就很清晰了
#include<cstring>
using namespace std;
class B
{
public:
B()
{
cout<<"Default Constructor\n";
}
B(char *s,double n)
{
strcpy(name,s);
b=n;
cout<<"Constructor\n";
}
B(const B&other)
{
strcpy(name,other.name);
b=other.b;
cout<<"Copy constructor."<<endl;
}
B& operator=(const B& other)
{
if(this!=&other)
{
strcpy(name,other.name);
b=other.b;
}
cout<<"Operator constructor."<<endl;
return *this;
}
~B()
{
cout<<"Destructor"<<" " <<name<<endl;
}
void getb(char*s,double&n)
{
strcpy(s,name);
n=b;
}
private:
char name[80];
double b;
};
////////////////////////////////////////////////////
int main()
{
B*p;
double n;
char s[80];
p=new B[3];
p[0]=B("ma",4.8);//这里会调用构造函数和赋值构造函数，有临时对象产生
p[1]=B("wang",3.6);
p[2]=B("li",3.1);
cout << "##############" << endl;
for(int i=0;i<3;i++)
{
p[i].getb(s,n);
cout<<s<<","<<n<<endl;
}
delete []p;
system("pause");
return 0;
}
//把3个构造函数写完就很清晰了
tdrhsb 2005-12-02
- 打赏
- 举报
明白了，我也是想有临时对象产生的。
SnowwhiteYqw 2005-12-02
- 打赏
- 举报
这里的类的构造函数没有动态分配内存，所以析构函数不需要释放内存。
但是你new了3 个B，这是动态分配的。所以你必须去delete它们。
但是你new了3 个B，这是动态分配的。所以你必须去delete它们。
wzjall 2005-12-01
- 打赏
- 举报
支持楼上的说法
Zark 2005-12-01
- 打赏
- 举报
接着qhfu的贴子往下说.
p=new B[3];已经创建了三个调用默认构造函数的对象
然后在
p[0]=B("ma",4.8);先建立一个B类的临时对象,然后拷贝到p所指向的第一个对象,这时你覆盖原有的第一个对象.然后临时对象析构.
这种做法是容易出现错误的,不宜提倡.不过仅对你的这个例子来说,倒也没有什么问题.
p=new B[3];已经创建了三个调用默认构造函数的对象
然后在
p[0]=B("ma",4.8);先建立一个B类的临时对象,然后拷贝到p所指向的第一个对象,这时你覆盖原有的第一个对象.然后临时对象析构.
这种做法是容易出现错误的,不宜提倡.不过仅对你的这个例子来说,倒也没有什么问题.
qhfu 2005-12-01
- 打赏
- 举报
p=new B[3];已经创建了三个调用默认构造函数的对象
