1.定义在类内部的函数,是隐式的内联函数;inline成员函数应该与相应的类定义在头文件中
2.所有成员都必须在类内声明,但是函数体定义可以是在类内也可以实在类外;但是类外部的定义,就必须包含它的类名::
3.如果我们给类定义了一个构造函数,那么编译器将不会自动为其生成默认构造函数。我们在不进行初始化而需要默认初始化的时候,就会出错。因此,只要我们为类定义了构造函数,就必须给类定义一个默认构造函数。防止出现默认初始化而出错
4.C++11中,如果要求默认的行为,可以在参数列表后添加 =defualt 来要求编译器生成构造函数
5.构造函数不应该轻易的覆盖掉类内的初始值,除非新值与原值不同。如果不能使用类内初始值,则所有构造函数都应显式的初始化内个内置类型的成员
.const在函数名前,表示的函数的返回值是常量:const func(){ ... }
const 在函数后,表示函数不能修改访问的对象:func() const { ... }
类的声明与定义:
最好令构造函数初始值的顺序与成员声明的顺序保持一致,而且,如果可能的话,尽量避免使用某些成员初始化其他成员。
这是一个头文件stock.h
#ifndef STOCK_H_
#define STOCK_H_
#include<string>
class Stock
{
private:
std:: string company;
long shares;
double share_val;
double total_val;
void set_tot() {total_val = shares * share_val; }
public:
Stock() = default; //默认构造函数
Stock(const std::string &co, long n = 0, double pr = 0.0); //我们编写的构造函数
//这里就要注意,我们直接进行了初始化。后面会讲到初始化和赋值的区别及影响
//要有直接初始化的好习惯
~Stock();//析构函数
void buy(long num, double price);
void sell(long num, double price);
void update(double price);
void show() const;
}
#endif
函数体文件stock.cpp
Stock:: Stock()
{
std::cout<<"default called\n";
company = "no name";
shares = 0;
share_val = 0.0;
total_val = 0.0;
}
Stock:: Stock(const std::string &co, long n, double pr)
{
company = co;
if(n<0)
{
std::cout<<"不能为负数";
shares = 0;
}
else
shares = n;
share_val = pr;
set_tot();
}
void Stock::show() const
{
//bulabula~~
}
然后可以在cpp的实现文件里写函数体等等。
-----
访问控制与封装
定义在public说明符之后的成员,可以被整个程序访问,public成员定义类的接口
定义在private说明符之后的成员,只能被类的成员函数访问。封装隐藏了类的实现细节
-----
struct和class的区别
我们可以使用两个关键字的任何一个定义类,唯一一点区别就是,两者的默认访问权限不一样
类可以在它的第一个访问说明符之前定义成员,那么这些成员属于private还是public呢?
如果我们使用struct定义类,则这些成员属于public
如果用class,则属于private
-----
-----
友元
当非该类的成员函数想要访问类的非公有成员时,使用友元
即,在类的定义内,添加该函数声明,并在函数声明前添加关键字friend
一般在类的最开始或末尾集中添加友元
-----------------------------------------------------------------------------------------------
类内友元的声明不能算作函数的声明,要想使用函数,还得在外面声明该函数
-----------------------------------------------------------------------------------------------
但是,对于类的使用者,如何知道友元的存在呢?
所以,一般,我们通常把友元的声明与类本身放置在同一个头文件中
因为它不是成员函数,因此不要使用 Time:: 限定符。 另外不要在定义中使用关键字friend。
-----
区别注意区分
Stock stock1("NanoSmart", 12, 20.0);// 这是直接初始化
Stock stock2 = Stock("Boffo", 2, 2.0);//初始化。这里有两种情况:1,同上;2,先创建一个临时变量用来存储boffo等的值,然后将值赋值给stock2,随后就析构该临时变量
stock1 = Stock("Nifty", 10, 50.0);//这里并不是初始化,而是赋值。创建临时变量用来存储nifty,然后将值赋值给stock1,随后就析构该临时变量
//因此,当进行赋值时,如果能直接初始化,就要初始化。会节省创建临时变量,然后赋值的过程和资源。
Stock *p = new Stock("Bulabula" ,6 ,6.6);
//创建一个Stock,并将其初始化,将该对象的地址赋值给p指针。
-----
重载成员函数
在参数数量和参数类型上有区别即可
不允许两个函数除了返回类型不同外,其他都相同,会报错
-----
可变数据成员
mutable关键字
当一个成员是一个可变成员,mutable a;
则,即使是被void func() const{ ++a; } 函数访问
则该变量在函数内也是可变的
就意味着,const对可变数据成员失效
-----
友元再探
一个类也可以成为另一个类的友元
友元没有传递性:即A是有友元B和C,但是BC之间并没有友元关系
-----
构造函数再探
class constref
{
public:
constref(int ii);
private:
int i;
const int ci;
int &ri;
};
//错误的,因为const和引用,必须初始化
constref::constref(int ii)
{
i = ii;
ci = ii;
ri = i;
}
//正确方法,显示的初始化const和引用
constref::constref(int ii): i(ii),ci(ii),ri(i){}
//构造函数中,并没有这些参数,但是我们可以通过:开头,作为分隔,来初始化
初始化顺序:在类的定义中,谁先出现,谁就先初始化
如下,构造函数中,我们用val初始化j,用j初始化i
但是,我们是先初始化i,因为i先出现在定义中,
即先用j初始化i,j未定义,报错
-----
隐式的类类型转换
如果有一个类,stonewt
它有一个构造函数stonewt(double lbs);
stonewt mycat;
mycat = 19.6;
//在这个过程中,首先
//先创建了一个临时stonewt的对象,并用19.6对其进行了初始化
//然后将该临时对象的内容复制给mycat
//中间发生了隐式的类型转换double->mycat
使用explicit关键字可以阻止隐式的类型转换
explicit stonewt(double lbs);
stonewt mycat;
mycat = 19.6;//错误,隐式的类型转换被禁止了
mycat = stonewt(19.6);//显式转换可行
mycat = (stonewt) 19.6;//可行
-----
类的静态成员
可以是常量,引用,指针等
类的静态成员不属于类的某个对象
但是我们扔可以使用类的对象、引用或者指针来访问静态成员
-----
因为静态数据成员不属于类的任何一个对象,所以他们并不是在创建类的对象时被定义的
这意味着他们不是由类的构造函数初始化的
一般来说,我们不在一个类内初始化静态成员,想法内的必须在类的外部定义和初始化静态成员
静态成员定义在任何函数之外,一旦被定义,将存在与程序的整个生命周期中
-----
----------------
如果想给类的private变量直接赋值
class B
{
private:
const int Months = 12;
double costs[Months];
.....
}//这是错误的,因为声明类只是描述了对象的形式,并没有创建对象,此时Months是没有存储值的空间的
class B
{
private:
static const int Months = 12;
double costs[Months];
.....
}//正确
8. 运算符重载
.h
class Time
{
private:
int hours;
int minutes;
public:
Time();
Time(int h, int m = 0);
void addm(int m);
void addh(int h);
//重载的+,-,*三个操作运算符.函数后的const表示不对读取的变量进行修改
Time operator+(const Time &t) const;
Time operator-(const Time &t) const;
Time operator*(const Time &t) const;
void show() const;
}
.cpp
//第一个Time是函数的返回类型,第二个Time表示,函数实在Time类中定义的
Time Time::operator+(const Time &t) const
{
Time Sum;
Sum.minutes = (minutes + t.minutes)%60;
Sum.hours = hours + (minutes + t.minutes)/60;
return Sum;
}
Time Time::operator-(const Time &t) const
{
Time Diff;
int one, two;
one = hours*60 + minutes;
two = t.hours*60 + t.minutes;
Diff.minutes = (one - two)%60;
Diff.hours = (one - two)/60;
return Diff;
}
//等等.....
9.友元(友元函数,友元类,友元成员函数)
友元函数:非成员函数可以访问类的私有成员。
首先说明,对于函数运算符的重载
A = B * 10; //其实就等于 A = B.operator*(10)
A = 10 * B; //但是,并没有A = 10.operator*(B),因此,重载只能先类后数,不能先数后类
创建友元:
(1)将原型放在类声明中,并在原型声明前加上关键字friend。
friend Time operator* (double m, const Time & t);
a.虽然函数实在类声明中声明的,但是它不是类的成员函数,因此不能用成员运算符来调用;
b.虽然不是成员函数,但是它与成员函数的访问权限相同。
(2)编写函数定义,因为它不是成员函数,因此不要使用 Time:: 限定符。 另外不要在定义中使用关键字friend。
Time operator* (double m , const Time &t )
{
Time result;
long totalminutes = t.hours * m + 60 + t.minutes * m;
result.minutes = totalminutes %60;
result.minutes = totalmunites/60;
return result;
}
10.重载<<运算符
我们想要直接cout<<Time;
如果按照传统的Time operator<<(ostream &s)
那么我们只能Time<<cout;,因为我们定义的是Time的成员,同上B*10可以,但是10*B不行。
因此我们可以定义为友元:
void operator<<(ostream &os, const Time & t)
{
os << t.hours <<"hours, "<< t.minutes << "minutes";
}
这样我们就可以使用cout<<Time;
但是,我们也只能这么使用。
而无法使用cout<<Time1 << Time2;
因为我们平常使用的cout,返回的都是ostream对象
因此我们需要如此修改
ostream & operator<<(ostream &os, const Time & t)
{
os << t.hours <<"hours, "<< t.minutes << "minutes";
return os;
}
此时我们就可以使用cout<<Time1 << Time2;
11.成员函数和非成员函数的区别:
Time operator+(const Time & t) const;
//通过成员函数,this指针,隐式的传递了一个参数,另一个参数通过t传递
friend Time operator+(const Time & t1, const Time & t2);
//两个参数通过t1,t2传递