c++ 05
构造函数
无参构造函数
有参构造函数
//无参构造函数，书写格式
#include <iostream>
using namespace std;
class Pet
{
public:
//函数声明
void exer1();
int exre2();
private:
//函数声明
}
void Pet::exer1(){}
int Pet::exer2(){}
int main(void)
{
Pet pet;
return 0;
}
//有参构造函数，书写模板
#include <iostream>
using namespace std;
class Pet
{
public:
Pet();
//函数和声明
private:
//函数和声明
};
int main(void)
{
Pet pet();
return 0;
}
//有参构造函数,实例
#include <iostream>
#include <string>
using namespace std;
class Pet
{
public:
//构造函数：用来初始化成员变量
//在生成对象的时候自动被调用
//函数需要的参数通过定义对象时
//在对象的后面括号中进行指定
//若没有自定义构造函数
//则默认自动会生成一个无参的构造函数
//若自定义了构造函数
//则不会生成一个无参的构造函数
Pet(string name, string voice
, string skill, int attack);
//无参构造函数
Pet()
{
cout << "call Pet()..." << endl;
}
void info();
private:
string m_strName;
string m_strVoice;
string m_strSkill;
int m_iAttack;
};
Pet::Pet(string name, string voice
, string skill, int attack)
{
m_strName = name;
m_strVoice = voice;
m_strSkill = skill;
m_iAttack = attack;
cout << "call Pet construct..." << endl;
}
void Pet::info()
{
cout << "战宠：" << m_strName
<< " 卖萌：" << m_strVoice
<< " 技能：" << m_strSkill
<< " 攻击力：" << m_iAttack
<< endl;
}
int main(void)
{
//生成对象pet时，自动调用构造函数
//构造函数需要的数据通过对象后面的括号进行指定
Pet pet("九尾狐", "叮叮叮", "魅惑", 20000);
pet.info();
//若生成对象时，没有传参，则默认调用无参构造函数
//若没有参数，则不需要在对象后面加括号
Pet pet2;
return 0;
}
拷贝构造函数
浅拷贝
深拷贝
#include <iostream>
#include <string.h>
using namespace std;
class MyString
{
public:
MyString()
{
m_pData = NULL;
}
MyString(const char *pData)
{
if (NULL != pData)
{
m_pData = new char[strlen(pData)+1];
if (NULL != m_pData)
{
strcpy(m_pData, pData);
}
}
cout << "called MyString(const char *pData)\n";
}
//若没有自定义拷贝构造函数
//则默认会生成一个拷贝构造函数
//默认生成的拷贝构造函数只是
//使用旧对象的成员变量依次对新对象的成员变量赋值
//将这种拷贝称之为浅拷贝
//在自定义的拷贝构造函数中
//若不仅仅拷贝变量的值，还拷贝额外的相关资源
//将这种拷贝称之为深拷贝
MyString(const MyString &other)
{
m_pData = NULL;
if (NULL != other.m_pData)
{
m_pData = new char[strlen(other.m_pData)+1];
if (NULL != m_pData)
{
strcpy(m_pData, other.m_pData);
}
}
cout << "called MyString(const MyString &other)\n";
}
const char *data()
{
return m_pData;
}
//析构函数
//在对象消亡的时候自动调用
//用来释放相关资源
//若没有自定义析构函数
//则会默认生成一个析构函数
//默认生成的析构函数什么都不做
~MyString()
{
if (NULL != m_pData)
{
delete []m_pData;
}
cout << "~MyString()...\n";
}
void myDelete()
{
if (NULL != m_pData)
{
delete []m_pData;
}
cout << "myDelete()...\n";
}
private:
char *m_pData;
};
int main(void)
{
MyString str("HelloWorld");
cout << str.data() << endl;
//使用旧对象的成员变量依次对新对象的成员变量赋值
//MyString str2 = str; //初始化
//调用拷贝构造函数
MyString str2(str);
cout << str2.data() << endl;
#if 0
str.myDelete();
str2.myDelete();
#endif
return 0;
}
类的成员变量
四类特殊的成员变量
// const 必须写在初始化成员列表中,值不可改
#include <iostream>
#include <string>
using namespace std;
class Person
{
public:
Person(): m_strName("newPerson")
, m_strDate("1999-11-17")
, m_strAddress("beijing")
{
}
Person(string name, string date
, string address)
: m_strDate(date)
{
m_strName = name;
m_strAddress = address;
}
void info()
{
cout << m_strName << ' ' << m_strDate
<< ' ' << m_strAddress << endl;
}
private:
string m_strName;
//const成员变量的初始化必须在初始化列表中进行
const string m_strDate;
string m_strAddress;
};
int main(void)
{
Person p1;
p1.info();
Person p2("aa", "1999-11-11", "beijing");
p2.info();
return 0;
}
//static 初始化在类外，不独立属于任何一个对象，为所有成员共有
#include <iostream>
#include <string>
using namespace std;
class Product
{
public:
Product(string name, float price, int num)
{
m_strName = name;
m_fPrice = price;
iNum = num;
}
void info()
{
cout << m_strName << ' ' << m_fPrice
<< ' ' << iNum << endl;
}
void setNum(int num)
{
iNum -= num;
}
private:
string m_strName;
float m_fPrice;
int iNum;
};
class Saller
{
public:
Saller(string name)
{
m_strName = name;
}
void sell(int num)
{
cout << m_strName << "卖了" << num << "瓶\n";
m_product.setNum(num);
}
void showWork()
{
cout << m_strName
<< ":";
m_product.info();
}
private:
string m_strName;
//静态的成员变量不独立属于某个对象
//为所有对象所共有
//类的大小不包括静态的成员变量
//也不包括函数
static Product m_product;
};
//静态的成员变量的初始化必须在类外进行
Product Saller::m_product("可口可乐", 3, 100);
int main(void)
{
Saller s1("zhangsan");
Saller s2("lisi");
s1.sell(23);
s1.showWork();
s2.sell(30);
s2.showWork();
cout << "product size:" << sizeof(Product) << endl;
cout << "saller size:" << sizeof(Saller) << endl;
return 0;
}
//& 引用 初始化必须在成员列表中
#include <iostream>
#include <string>
using namespace std;
class Product
{
public:
Product(string name, float price, int num)
{
m_strName = name;
m_fPrice = price;
iNum = num;
}
void info()
{
cout << m_strName << ' ' << m_fPrice
<< ' ' << iNum << endl;
}
void setNum(int num)
{
iNum -= num;
}
private:
string m_strName;
float m_fPrice;
int iNum;
};
class Saller
{
public:
//若成员变量为引用
//则初始化必须在初始化列表中进行
Saller(string name, Product &ref)
: m_product(ref)
{
m_strName = name;
}
void sell(int num)
{
cout << m_strName << "卖了" << num << "瓶\n";
m_product.setNum(num);
}
void showWork()
{
cout << m_strName
<< ":";
m_product.info();
}
private:
string m_strName;
Product &m_product;
};
class SuperMarket
{
public:
SuperMarket(): m_product("kele", 2, 100)
, m_saller("zhangsan", m_product)
, m_saller2("lisi", m_product)
{
}
void work()
{
m_saller.sell(20);
m_saller.showWork();
m_saller2.sell(18);
m_saller2.showWork();
}
private:
//如果一个类的对象作为另外一个类的成员变量
//那么将该对象称之为子对象
//该对象的初始化必须在初始化列表进行
Product m_product;
Saller m_saller;
Saller m_saller2;
};
int main(void)
{
SuperMarket sm;
sm.work();
cout << "product size:" << sizeof(Product) << endl;
cout << "saller size:" << sizeof(Saller) << endl;
cout << "supermarket size:"
<< sizeof(SuperMarket) << endl;
return 0;
}
//子对象 若类中有子对象，则先执行子对象，再执行父对象，析构函数执行顺序相反
#include <iostream>
#include <string>
using namespace std;
class A
{
public:
~A()
{
cout << "called ~A()..." << endl;
}
A()
{
m_i = 0;
cout << "called A()..." << endl;
}
A(int i)
{
m_i = i;
cout << "called A(int i)..." << endl;
}
int m_i;
};
class B
{
public:
~B()
{
cout << "called ~B()...\n";
}
//B()
B():m_a(189)
{
cout << "called B()...\n";
}
//B(int j)
B(int j):m_a(90)
{
m_j = j;
cout << "called B(int j)...\n";
}
private:
//如果没有在初始化列表中显式的调用子对象的构造函数
//那么会自动默认调用子对象的无参构造函数来初始化
A m_a;
int m_j;
};
int main(void)
{
//若类中含有子对象，则先执行子对象的构造函数
//在执行该类的构造函数
//析构函数的执行顺序和构造函数的相反
// B b1;
B b2(12);
return 0;
}
