class Date
{
public:
//初始化列表
Date(int year, int month, int day)
: _year(year)
, _month(month)
, _day(day)
{}
private:
int _year;
int _month;
int _day;
};
(2)使用
注意事项
类中包含以下成员，必须放在初始化列表位置进行初始化：
引用成员变量
const成员变量
自定义类型成员(且该类没有默认构造函数时)
cpp复制代码
class A
{
public:
//A(int a = 0, int b = 1)
A(int a, int b)
:_a(a)
{
cout << "A(int a = 0)" << endl;
}
private:
int _a;
};
class Date
{
public:
// 初始化列表是每个成员变量定义初始化的位置
// 能用初始化列表就建议用初始化列表
Date(int year, int month, int day, int& x)
:_year(year)
,_month(month)
,_day(day)
,_n(1)
,_ref(x)
,_aa(1, 2)
,_p((int*)malloc(sizeof(4) * 10))
{
if (_p == nullptr)
{
perror("malloc fail");
}
for (size_t i = 0; i < 10; i++)
{
_p[i] = 0;
}
}
private:
// 声明
int _year;
int _month;
int _day;
// 必须走初始化
const int _n;
int& _ref;
A _aa;
int* _p;
};
int n = 0;
class A
{
public:
A()
{
++n;
}
A(const A& aa)
{
++n;
}
};
A Func()
{
A aa;
return aa;
}
int main()
{
A aa1;
A aa2;
Func();
cout << n << endl;
return 0;
}
由于各个编译器的优化程度不一样，所以导致最后调用的次数可能会不同，因此这种写法具有一定的风险性。
写法2：设置成静态成员，并突破类域和访问限定符
cpp复制代码
class A
{
public:
A()
{
++n;
}
A(const A& aa)
{
++n;
}
//不是属于某一个对象，属于所有对象，属于整个类
static int n ;//在类内声明
};
int A::n = 0;//在类外定义
A Func()
{
A aa;
return aa;
}
int main()
{
A aa1;
A aa2;
Func();
//三种访问形式
cout << aa1.n << endl;
cout << aa2.n << endl;
cout << A::n << endl;
return 0;
}
写法3：存在访问限定符
cpp复制代码
class A
{
public:
A()
{
++n;
}
A(const A& aa)
{
++n;
}
int GetN()
{
return n;
}
private:
//不是属于某一个对象，属于所有对象，属于整个类
static int n ;//在类内声明
};
int A::n = 0;//在类外定义
A Func()
{
A aa;
return aa;
}
int main()
{
A aa1;
A aa2;
Func();
cout << aa1.GetN() << endl;
return 0;
}
写法4：静态成员函数写法
cpp复制代码
class A
{
public:
A()
{
++n;
}
A(const A& aa)
{
++n;
}
//静态成员函数没有this指针
static int GetN()
{
return n;
}
private:
//不是属于某一个对象，属于所有对象，属于整个类
static int n ;//在类内声明
};
int A::n = 0;//在类外定义
A Func()
{
A aa;
return aa;
}
int main()
{
A aa1;
A aa2;
Func();
cout << A::GetN() << endl;
return 0;
}
class Time
{
friend class Date;// 声明日期类为时间类的友元类，则在日期类中就直接访问Time类中的私有成员变量
public:
Time(int hour = 0, int minute = 0, int second = 0)
: _hour(hour)
, _minute(minute)
, _second(second)
{}
private:
int _hour;
int _minute;
int _second;
};
class Date
{
public:
Date(int year = 1900, int month = 1, int day = 1)
: _year(year)
, _month(month)
, _day(day)
{}
void SetTimeOfDate(int hour, int minute, int second)
{
// 直接访问时间类私有的成员变量
_t._hour = hour;
_t._minute = minute;
_t._second = second;
}
private:
int _year;
int _month;
int _day;
Time _t;
};
class A
{
public:
//内部类天生就是外部类的友元类
class B
{
public:
void func(A* p)
{
p->_a1++;
}
};
private:
int _a1;
int _a2;
};
int main()
{
cout << sizeof(A) << endl;
A::B bb;
}
2.特性
内部类可以定义在外部类的public、protected、private都是可以的。
注意内部类可以直接访问外部类中的static成员，不需要外部类的对象/类名。
sizeof(外部类)=外部类，和内部类没有任何关系。
内部类的大小
cpp复制代码
class A
{
public:
class B
{
private:
int _b1;
};
private:
int _a1;
int _a2;
};
int main()
{
cout << sizeof(A) << endl;//8
}
类B受类A的类域限制，所以类A里其实是没有类B的，类B可以理解为和全局变量没有区别。
类B在创建对象时受到类A封装的限制。
cpp复制代码
int main()
{
A::B bb;//这样创建对象
}
如果将类B设置成private，则无法访问
六.匿名对象
cpp复制代码
class A
{
public:
A(int a = 0)
:_a(a)
{
cout << "A(int a)" << endl;
}
~A()
{
cout << "~A()" << endl;
}
private:
int _a;
};
int main()
{
// 有名对象
A aa1;
// 匿名对象
// 特点：生命周期只在当前一行
A();
A(10);
return 0;
}
