1.类内函数声明后加const,即const修饰成员函数
如:void function() const{}
#include <iostream>
using namespace std;
class aa
{
int num;
public:
aa()
{
int b = 10;
num = b;
};
void out1()
{
cout << num << endl;
}
void out2() const
{
cout << num << endl;
}
void out3() const
{
num += 10; //出错,const函数不能修改其数据成员
cout << num << endl;
}
};
int main()
{
aa a1;
a1.out1();
a1.out2();
a1.out3();
const aa a2;
a2.out1(); // 错误,const的成员 不能访问非const的函数
a2.out2();
a2.out3();
return 0;
}
在类成员函数的声明和定义中,
const的函数不能对其数据成员进行修改操作。
const的对象,不能引用非const的成员函数。
2.内联函数inline
使用函数能够避免将相同代码重写多次的麻烦,还能减少可执行程序的体积,但也会带来程序运行时间上的开销。
函数调用在执行时,首先要在栈中为形参和局部变量分配存储空间,然后还要将实参的值复制给形参,接下来还要将函数的返回地址(该地址指明了函数执行结束后,程序应该回到哪里继续执行)放入栈中,最后才跳转到函数内部执行。这个过程是要耗费时间的。
另外,函数执行 return 语句返回时,需要从栈中回收形参和局部变量占用的存储空间,然后从栈中取出返回地址,再跳转到该地址继续执行,这个过程也要耗费时间。
总之,使用函数调用语句和直接把函数中的代码重新抄写一遍相比,节省了人力,但是带来了程序运行时间上的额外开销。
一般情况下,这个开销可以忽略不计。但是,如果一个函数内部没有几条语句,执行时间本来就非常短,那么这个函数调用产生的额外开销和函数本身执行的时间相比,就显得不能忽略了。假如这样的函数在一个循环中被上千万次地执行,函数调用导致的时间开销可能就会使得程序运行明显变慢。
作为特别注重程序执行效率,适合编写底层系统软件的高级程序设计语言,C++ 用 inline 关键字较好地解决了函数调用开销的问题。
在C++中,可以在定义函数时,在返回值类型前面加上 inline 关键字。
如:
inline int Max (int a, int b)
{
if(a > b)
return a;
return b;
}
增加了 inline 关键字的函数称为“内联函数”。内联函数和普通函数的区别在于:当编译器处理调用内联函数的语句时,不会将该语句编译成函数调用的指令,而是直接将整个函数体的代码插人调用语句处,就像整个函数体在调用处被重写了一遍一样。
有了内联函数,就能像调用一个函数那样方便地重复使用一段代码,而不需要付出执行函数调用的额外开销。很显然,使用内联函数会使最终可执行程序的体积增加。以时间换取空间,或增加空间消耗来节省时间,这是计算机学科中常用的方法。
内联函数中的代码应该只是很简单、执行很快的几条语句。如果一个函数较为复杂,它执行的时间可能上万倍于函数调用的额外开销,那么将其作为内联函数处理的结果是付出让代码体积增加不少的代价,却只使速度提高了万分之一,这显然是不划算的。
有时函数看上去很简单,例如只有一个包含一两条语句的循环,但该循环的执行次数可能很多,要消耗大量时间,那么这种情况也不适合将其实现为内联函数。
另外,需要注意的是,调用内联函数的语句前必须已经出现内联函数的定义(即整个数体),而不能只出现内联函数的声明。
3.显示声明explicit
首先, C++中的explicit关键字只能用于修饰只有一个参数的类构造函数, 它的作用是表明该构造函数是显示的, 而非隐式的, 跟它相对应的另一个关键字是implicit, 意思是隐藏的,类构造函数默认情况下即声明为implicit(隐式).
那么显示声明的构造函数和隐式声明的有什么区别呢? 我们来看下面的例子:
class CxString // 没有使用explicit关键字的类声明, 即默认为隐式声明
{
public:
char *_pstr;
int _size;
CxString(int size)
{
_size = size; // string的预设大小
_pstr = malloc(size + 1); // 分配string的内存
memset(_pstr, 0, size + 1);
}
CxString(const char *p)
{
int size = strlen(p);
_pstr = malloc(size + 1); // 分配string的内存
strcpy(_pstr, p); // 复制字符串
_size = strlen(_pstr);
}
// 析构函数这里不讨论, 省略...
};
// 下面是调用:
CxString string1(24); // 这样是OK的, 为CxString预分配24字节的大小的内存
CxString string2 = 10; // 这样是OK的, 为CxString预分配10字节的大小的内存
CxString string3; // 这样是不行的, 因为没有默认构造函数, 错误为: “CxString”: 没有合适的默认构造函数可用
CxString string4("aaaa"); // 这样是OK的
CxString string5 = "bbb"; // 这样也是OK的, 调用的是CxString(const char *p) 中的隐式调用
CxString string6 = 'c'; // 这样也是OK的, 其实调用的是CxString(int size), 且size等于'c'的ascii码
string1 = 2; // 这样也是OK的, 为CxString预分配2字节的大小的内存
string2 = 3; // 这样也是OK的, 为CxString预分配3字节的大小的内存
string3 = string1; // 这样也是OK的, 至少编译是没问题的, 但是如果析构函数里用free释放_pstr内存指针的时候可能会报错, 完整的代码必须重载运算符"=", 并在其中处理内存释放
上面的代码中, "CxString string2 = 10;"这句为什么是可以的呢? 在C++中, 如果的构造函数只有一个参数时,那么在编译的时候就会有一个缺省的转换操作:将该构造函数对应数据类型的数据转换为该类对象.也就是说 “CxString string2 = 10;” 这段代码,编译器自动将整型转换为CxString类对象,CxString string5 = "bbb"同理。
实际上等同于下面的操作:
CxString string2(10);
或
CxString temp(10);
CxString string2 = temp;
但是, 上面的代码中的_size代表的是字符串内存分配的大小, 那么调用的第二句 “CxString string2 = 10;” 和第六句 “CxString string6 = ‘c’;” 就显得不伦不类, 而且容易让人疑惑. 有什么办法阻止这种用法呢? 答案就是使用explicit关键字. 我们把上面的代码修改一下, 如下:
class CxString // 使用关键字explicit的类声明, 显示转换
{
public:
char *_pstr;
int _size;
explicit CxString(int size)
{
_size = size;
// 代码同上, 省略...
}
CxString(const char *p)
{
// 代码同上, 省略...
}
};
// 下面是调用:
CxString string1(24); // 这样是OK的
CxString string2 = 10; // 这样是不行的, 因为explicit关键字取消了隐式转换
CxString string3; // 这样是不行的, 因为没有默认构造函数
CxString string4("aaaa"); // 这样是OK的
CxString string5 = "bbb"; // 这样也是OK的, 调用的是CxString(const char *p)
CxString string6 = 'c'; // 这样是不行的, 其实调用的是CxString(int size), 且size等于'c'的ascii码, 但explicit关键字取消了隐式转换
string1 = 2; // 这样也是不行的, 因为取消了隐式转换
string2 = 3; // 这样也是不行的, 因为取消了隐式转换
string3 = string1; // 这样也是不行的, 因为取消了隐式转换, 除非类实现操作符"="的重载, explicit关键字的作用就是防止类构造函数的隐式自动转换.
上面也已经说过了, explicit关键字只对有一个参数的类构造函数有效, 如果类构造函数参数大于或等于两个时, 是不会产生隐式转换的, 所以explicit关键字也就无效了. 例如:
class CxString // explicit关键字在类构造函数参数大于或等于两个时无效
{
public:
char *_pstr;
int _age;
int _size;
explicit CxString(int age, int size)
{
_age = age;
_size = size;
// 代码同上, 省略...
}
CxString(const char *p)
{
// 代码同上, 省略...
}
};
// 这个时候有没有explicit关键字都是一样的
但是, 也有一个例外, 就是当除了第一个参数以外的其他参数都有默认值的时候, explicit关键字依然有效, 此时, 当调用构造函数时只传入一个参数, 等效于只有一个参数的类构造函数, 例子如下:
class CxString // 使用关键字explicit声明
{
public:
int _age;
int _size;
explicit CxString(int age, int size = 0)
{
_age = age;
_size = size;
// 代码同上, 省略...
}
CxString(const char *p)
{
// 代码同上, 省略...
}
};
CxString string1(24); // 这样是OK的
CxString string2 = 10; // 这样是不行的, 因为explicit关键字取消了隐式转换
CxString string3; // 这样是不行的, 因为没有默认构造函数
string1 = 2; // 这样也是不行的, 因为取消了隐式转换
string2 = 3; // 这样也是不行的, 因为取消了隐式转换
string3 = string1; // 这样也是不行的, 因为取消了隐式转换, 除非类实现操作符"="的重载
4.类内成员函数为operator+强转数据类型名
#include <iostream>
using namespace std;
class my_class
{
public:
operator int() const//定义了一个将类转化为int的转换函数,且通常定义为常函数
{
cout << "convert_to_int" << endl;
return 1;
}
};
int main()
{
my_class a;
int i_a = (int)a;//第一次显式的转换
cout << a << endl;//第二次隐式的转换
return 0;
}
当然也可以转化为任意其他的类型,只需要改变转换函数即可。
但是在定义转化函数时,要避免出现二义性,比如不要同时提供多个符合条件的转换函数:
#include <iostream>
using namespace std;
class my_class
{
public:
operator double()//定义了一个将类转化为double的转换函数
{
cout << "convert_to_double" << endl;
return 1.1;
}
operator int()//定义了一个将类转化为int的转换函数
{
cout << "convert_to_int" << endl;
return 1;
}
};
int main()
{
my_class a;
cout << a << endl;//报错
return 0;
}
在VS上得到如下的报错信息:
有多个运算符 “<<” 与这些操作数匹配
1
当然,若同时需要这两个转换函数,这个错误也可以通过很多方法来解决,比如显式的指定要输出的是哪种类型,而不是让编译器自己去选择:
cout << (double)a << endl;
或者指定其中一个转换函数只能显式的转换,而不能隐式的转换
explicit operator double()
{
cout << "convert_to_double" << endl;
return 1.1;
}
都将得到正确的结果。
类模板不同类型之间的转换
template<typename _Tp> class Person
{
public:
string m_Name;
_Tp m_Age;
Person(){}
Person(string name, int age)
{
this->m_Name = name;
this->m_Age = age;
}
template<typename _Tp2>
operator Person<_Tp2>()
{
string namex = this->m_Name;
_Tp2 agex = this->m_Age * 10;
Person<_Tp2>temp(namex, agex);
return temp;
}
};
int main() {
Person<int>p1("liu", 18);
Person<float>p2 = Person<float>(p1);
cout << "p1的姓名:" << p1.m_Name << " p1的年龄" << p1.m_Age << endl;
cout << "p2的姓名:" << p2.m_Name << " p2的年龄" << p2.m_Age << endl;
system("pause");
return 0;
}