namespace
在变量或函数前面加上命名空间,用来区分其它位置中的同名函数或变量。
#include <iostream>
using namespace std;
namespace A
{
int a = 100;
namespace B
{
int a =20;
}
}
int a = 200;
int main(int argc, char *argv[])
{
cout <<"A::a ="<< A::a << endl;
cout <<"A::B::a ="<<A::B::a << endl;
cout <<"a ="<<a << endl;
cout <<"::a ="<<::a << endl;
int a = 30;
cout <<"a ="<<a << endl;
cout <<"::a ="<<::a << endl;
return 0;
}
class 和 stuct 区别
-
struct更适合看成是一个数据结构的实现体,class更适合看成是一个对象的实现体。
-
struct没有继承,没有封装,要说封装只有初步封装。而class把数据,接口可以以三种类型封装,private,public,protected;还可以继承和派生。
-
它们都可以提供自己的接口函数,构造函数。一个类可以由结构继承而来。struct只能叫做数据的集合,外部可以任意访问,但是类就完成了封装,维护了数据安全,这就是面向对象的理念。
-
class里可以定义私有成员和保护成员而结构体里所有的成员,均为公用成员
从上面的区别,可以看出,struct更适合看成是一个数据结构的实现体,class更适合看成是一个对象的实现体。
inline
引入 inline 关键字的原因
在 c/c++ 中,为了解决一些频繁调用的小函数大量消耗栈空间(栈内存)的问题,特别的引入了 inline 修饰符,表示为内联函数。
栈空间就是指放置程序的局部数据(也就是函数内数据)的内存空间。
在系统下,栈空间是有限的,假如频繁大量的使用就会造成因栈空间不足而导致程序出错的问题,如,函数的死循环递归调用的最终结果就是导致栈内存空间枯竭。
#include <stdio.h>
inline const char *num_check(int v)
{
return (v % 2 > 0) ? "奇" : "偶";
}
int main(void)
{
int i;
for (i = 0; i < 100; i++)
printf("%02d %s\n", i, num_check(i));
return 0;
}
在内部的工作就是在每个 for 循环的内部任何调用 dbtest(i) 的地方都换成了 (i%2>0)?“奇”:“偶”,这样就避免了频繁调用函数对栈内存重复开辟所带来的消耗。
-
inline使用限制
inline 的使用是有所限制的,inline 只适合涵数体内代码简单的涵数使用,不能包含复杂的结构控制语句例如 while、switch,并且不能内联函数本身不能是直接递归函数(即,自己内部还调用自己的函数)。
-
inline仅是一个对编译器的建议
inline 函数仅仅是一个对编译器的建议,所以最后能否真正内联,看编译器的意思,它如果认为函数不复杂,能在调用点展开,就会真正内联,并不是说声明了内联就会内联,声明内联只是一个建议而已。
-
建议 inline 函数的定义放在头文件中
其次,因为内联函数要在调用点展开,所以编译器必须随处可见内联函数的定义,要不然就成了非内联函数的调用了。所以,这要求每个调用了内联函数的文件都出现了该内联函数的定义。因此,将内联函数的定义放在头文件里实现是合适的,省却你为每个文件实现一次的麻烦。
-
声明跟定义要一致:如果在每个文件里都实现一次该内联函数的话,那么,最好保证每个定义都是一样的,否则,将会引起未定义的行为。如果不是每个文件里的定义都一样,那么,编译器展开的是哪一个,那要看具体的编译器而定。所以,最好将内联函数定义放在头文件中。
-
inline 是一种"用于实现的关键字"
关键字 inline 必须与函数定义体放在一起才能使函数成为内联,仅将 inline 放在函数声明前面不起任何作用。
inline void Foo(int x, int y);
void Foo(int x, int y){}
- 慎用 inline
内联是以代码膨胀(复制)为代价,仅仅省去了函数调用的开销,从而提高函数的执行效率。
如果执行函数体内代码的时间,相比于函数调用的开销较大,那么效率的收获会很少。另一方面,每一处内联函数的调用都要复制代码,将使程序的总代码量增大,消耗更多的内存空间。 - 以下情况不宜使用内联:
(1)如果函数体内的代码比较长,使用内联将导致内存消耗代价较高。
(2)如果函数体内出现循环,那么执行函数体内代码的时间要比函数调用的开销大。
类中的成员函数与inline
定义在类中的成员函数默认都是内联的,如果在类定义时就在类内给出函数定义,那当然最好。如果在类中未给出成员函数定义,而又想内联该函数的话,那在类外要加上 inline,否则就认为不是内联的。
class A
{
public:void Foo(int x, int y) { }
}
、、、、、、、、、====
class A
{
public:
void Foo(int x, int y);
}
inline void A::Foo(int x, int y){}
mutable 和 volatile
mutable
mutable
只能作用在类成员上,指示其数据总是可变的。不能和const 同时修饰一个成员,但能配合使用:const
修饰的方法中,mutable
修饰的成员数据可以发生改变,除此之外不应该对类/对象带来副作用。
考虑一个mutable
的使用场景:呼叫系统中存有司机(Driver
)的信息,为了保护司机的隐私,司机对外展现的联系号码每隔五分钟从空闲号码池更新一次。根据需求,Driver
类的实现如下伪代码:
class Driver {
private:
...
string phone;
mutable string displayPhone;
public:
string getDisplayPhone() const {
if (needUpdate()) {
lock.lock();
if (needUpdate()) {
updateDisplayPhone();
}
lock.unlock();
}
return displayPhone;
}
};
在上述代码中,const
方法中不允许对常规成员进行变动,但mutable成员不受此限制。对Driver
类来说,其固有属性(姓名、年龄、真实手机号等)未发生改变,符合const
修饰。mutable
让一些随时可变的展示属性能发生改变,达到了灵活编程的目的。
volatile
volatile
用于修饰成员或变量,指示其修饰对象可能随时变化,编译器不要对所修饰变量进行优化(缓存),每次取值应该直接读取内存。由于volatile
的变化来自运行期,其可以与const
一起使用。两者一起使用可能让人费解,如果考虑场景就容易许多:CPU和GPU通过映射公用内存中的同一块,GPU可能随时往共享内存中写数据。对CPU上的程序来说,const修饰变量一直是右值,所以编译通过。但其变量内存中的值在运行期间可能随时在改变,volatile
修饰是正确做法。
在多线程环境下,volatile
可用作内存同步手段。例如多线程爆破密码:
volatile bool found = false;
void run(string target) {
while (!found) {
if (target == hash) {
found = true;
break;
}
}
}
在volatile
的修饰下,每次循环都会检查内存中的值,达到同步的效果。
需要注意的是,volatile的值可能随时会变,期间会导致非预期的结果。例如下面的例子求平方和:
double square(volatile double a, volatile double b) {
return (a + b) * (a + b);
}
应该改成:
double square(volatile double a, volatile double b) {
double c = a + b;
return c * c;
}
一般说来,volatile用在如下的几个地方:
- 中断服务程序中修改的供其它程序检测的变量需要加volatile;
- 多任务环境下各任务间共享的标志应该加volatile;
- 存储器映射的硬件寄存器通常也要加volatile说明,因为每次对它的读写都可能有不同意义;
总结
- mutable只能用与类变量,不能与const同时使用;在const修饰的方法中,mutable变量数值可以发生改变;
- volatile只是运行期变量的值随时可能改变,这种改变即可能来自其他线程,也可能来自外部系统。
static
什么是static?
static 是 C/C++ 中很常用的修饰符,它被用来控制变量的存储方式和可见性。
在 C/C++ 中static的作用
总的来说
(1)在修饰变量的时候,static 修饰的静态局部变量只执行初始化一次,而且延长了局部变量的生命周期,直到程序运行结束以后才释放。
(2)static 修饰全局变量的时候,这个全局变量只能在本文件中访问,不能在其它文件中访问,即便是 extern 外部声明也不可以。
(3)static 修饰一个函数,则这个函数的只能在本文件中调用,不能被其他文件调用。static 修饰的变量存放在全局数据区的静态变量区,包括全局静态变量和局部静态变量,都在全局数据区分配内存。初始化的时候自动初始化为 0。
(4)不想被释放的时候,可以使用static修饰。比如修饰函数中存放在栈空间的数组。如果不想让这个数组在函数调用结束释放可以使用 static 修饰。
(5)考虑到数据安全性(当程序想要使用全局变量的时候应该先考虑使用 static)。
c++ static 用法
static 关键字最基本的用法是:
- 被 static 修饰的变量属于类变量,可以通过类名.变量名直接引用,而不需要 new 出一个类来
- 被 static 修饰的方法属于类方法,可以通过类名.方法名直接引用,而不需要 new 出一个类来
被 static 修饰的变量、被 static 修饰的方法统一属于类的静态资源,是类实例之间共享的,换言之,一处变、处处变。
在 C++ 中,静态成员是属于整个类的而不是某个对象,静态成员变量只存储一份供所有对象共用。所以在所有对象中都可以共享它。使用静态成员变量实现多个对象之间的数据共享不会破坏隐藏的原则,保证了安全性还可以节省内存。
静态成员的定义或声明要加个关键 static。静态成员可以通过双冒号来使用即 <类名>::<静态成员名>。
class Point
{
public:
void init()
{
printf("%d\n", m_nPointCount);
}
static void output()
{
printf("%d\n", m_nPointCount);
}
private:
static int m_nPointCount;
};
void main()
{
Point pt;
pt.init();
pt.output();
Point::output();
}
总结:
(1)静态成员函数中不能调用非静态成员。
(2)非静态成员函数中可以调用静态成员。因为静态成员属于类本身,在类的对象产生之前就已经存在了,所以在非静态成员函数中是可以调用静态成员的。
(3)静态成员变量使用前必须先初始化(如 int MyClass::m_nNumber = 0;),否则会在 linker 时出错。
静态数据成员
(1)静态数据成员可以实现多个对象之间的数据共享,它是类的所有对象的共享成员,它在内存中只占一份空间,如果改变它的值,则各对象中这个数据成员的值都被改变。
(2)静态数据成员是在程序开始运行时被分配空间,到程序结束之后才释放,只要类中指定了静态数据成员,即使不定义对象,也会为静态数据成员分配空间。
(3)静态数据成员可以被初始化,但是只能在类体外进行初始化,若未对静态数据成员赋初值,则编译器会自动为其初始化为 0。
(4)静态数据成员既可以通过对象名引用,也可以通过类名引用。
静态成员函数
(1)静态成员函数和静态数据成员一样,他们都属于类的静态成员,而不是对象成员。
(2)非静态成员函数有 this 指针,而静态成员函数没有 this 指针。
(3)静态成员函数主要用来方位静态数据成员而不能访问非静态成员。
exeplicit,delete …
C++ 的类有四类特殊成员函数,它们分别是:默认构造函数、析构函数、拷贝构造函数以及拷贝赋值运算符。
这些类的特殊成员函数负责创建、初始化、销毁,或者拷贝类的对象。
如果程序员没有显式地为一个类定义某个特殊成员函数,而又需要用到该特殊成员函数时,则编译器会隐式的为这个类生成一个默认的特殊成员函数。
C++11 标准引入了一个新特性:"=default"函数。程序员只需在函数声明后加上“=default;”,就可将该函数声明为 "=default"函数,编译器将为显式声明的 “=default"函数自动生成函数体。
为了能够让程序员显式的禁用某个函数,C++11 标准引入了一个新特性:”=delete"函数。程序员只需在函数声明后上“=delete;”,就可将该函数禁用。
class X
{
public:
X() = default;
X(int i)
{
a = i;
}
private:
int a;
};
X obj;
class X1
{
public:
int f() = default;
X1(int, int) = default;
X1(int = 1) = default;
};
class X2
{
public:
X2() = default;
X2(const X&);
X2& operator = (const X&);
~X2() = default;
};
X2::X2(const X&) = default;
X2& X2::operator= (const X2&) = default;
class X3
{
public:
X3();
X3(const X3&) = delete;
X3& operator = (const X3 &) = delete;
};
class X4
{
public:
X4(double)
{
}
X4(int) = delete;
};
class X5
{
public:
void *operator new(size_t) = delete;
void *operator new[](size_t) = delete;
};
void mytest()
{
X4 obj1;
X4 obj2=obj1;
X4 obj3;
obj3=obj1;
X5 *pa = new X5;
X5 *pb = new X5[10];
return;
}
C++中的explicit关键字只能用于修饰只有一个参数的类构造函数, 它的作用是表明该构造函数是显示的, 而非隐式的, 跟它相对应的另一个关键字是implicit, 意思是隐藏的,类构造函数默认情况下即声明为implicit(隐式)。
class CxString
{
public:
char *_pstr;
int _size;
CxString(int size)
{
_size = size;
_pstr = malloc(size + 1);
memset(_pstr, 0, size + 1);
}
CxString(const char *p)
{
int size = strlen(p);
_pstr = malloc(size + 1);
strcpy(_pstr, p);
_size = strlen(_pstr);
}
};
CxString string1(24);
CxString string2 = 10;
CxString string3;
CxString string4("aaaa");
CxString string5 = "bbb";
CxString string6 = 'c';
string1 = 2;
string2 = 3;
string3 = string1;
上面的代码中, “CxString string2 = 10;” 这句为什么是可以的呢? 在C++中, 如果的构造函数只有一个参数时, 那么在编译的时候就会有一个缺省的转换操作:将该构造函数对应数据类型的数据转换为该类对象. 也就是说 “CxString string2 = 10;” 这段代码, 编译器自动将整型转换为CxString类对象, 实际上等同于下面的操作:
CxString string2(10);
或
CxString temp(10);
CxString string2 = temp;
但是, 上面的代码中的_size代表的是字符串内存分配的大小, 那么调用的第二句 “CxString string2 = 10;” 和第六句 “CxString string6 = ‘c’;” 就显得不伦不类, 而且容易让人疑惑. 有什么办法阻止这种用法呢? 答案就是使用explicit关键字. 即在 CxString(int size) 前面加上explicit 关键字。explicit关键字的作用就是防止类构造函数的隐式自动转换.
注意: explicit关键字只对有一个参数的类构造函数有效, 如果类构造函数参数大于或等于两个时, 是不会产生隐式转换的, 所以explicit关键字也就无效了。但是, 也有一个例外, 就是当除了第一个参数以外的其他参数都有默认值的时候, explicit关键字依然有效, 此时, 当调用构造函数时只传入一个参数, 等效于只有一个参数的类构造函数, 例子如下:
class CxString
{
public:
int _age;
int _size;
explicit CxString(int age, int size = 0)
{
_age = age;
_size = size;
}
CxString(const char *p)
{
}
};
CxString string1(24);
CxString string2 = 10;
CxString string3;
string1 = 2;
string2 = 3;
string3 = string1;
virtural, final,overide
virtual在英文中表示“虚”、“虚拟”的含义。c++中的关键字“virtual”主要用在两个方面:虚函数与虚基类。下面将分别从这两个方面对virtual进行介绍。
虚函数
虚函数源于c++中的类继承,是多态的一种。在c++中,一个基类的指针或者引用可以指向或者引用派生类的对象。同时,派生类可以重写基类中的成员函数。这里“重写”的要求是函数的特征标(包括参数的数目、类型和顺序)以及返回值都必须与基类中的函数一致。如下所示:
class base
{
int a,b;
public:
void test(){ cout<<"基类方法!"<<endl; }
virtual ~base(){}
};
class inheriter:public base
{
public:
void test(){ cout<<"派生类方法!"<<endl; }
};
可以在基类中将被重写的成员函数设置为虚函数,其含义是:当通过基类的指针或者引用调用该成员函数时,将根据指针指向的对象类型确定调用的函数,而非指针的类型。如下,是未将test()函数设置为虚函数前的执行结果:
base *p1=new base;
base *p2=new inheriter;
p1->test();
p2->test();
在将test()函数设置为virtual后,执行结果如下:
base *p1=new base;
base *p2=new inheriter;
p1->test();
p2->test();
如此,便可以将基类与派生类的同名方法区分开,实现多态。
说明:
- 只需将基类中的成员函数声明为虚函数即可,派生类中重写的virtual函数自动成为虚函数;
- 基类中的析构函数必须为虚函数,否则会出现对象释放错误。以上例说明,如果不将基类的析构函数声明为virtual,那么在调用delete p2;语句时将调用基类的析构函数,而不是应当调用的派生类的析构函数,从而出现对象释放错误的问题。
- 虚函数的使用将导致类对象占用更大的内存空间。对这一点的解释涉及到虚函数调用的原理:编译器给每一个包括虚函数的对象添加了一个隐藏成员:指向虚函数表的指针。虚函数表(virtual function table)包含了虚函数的地址,由所有虚函数对象共享。当派生类重新定义虚函数时,则将该函数的地址添加到虚函数表中。无论一个类对象中定义了多少个虚函数,虚函数指针只有一个。相应地,每个对象在内存中的大小要比没有虚函数时大4个字节(32位主机,不包括虚析构函数)。如下:
cout<<sizeof(base)<<endl;
cout<<sizeof(inheriter)<<endl;
base类中包括了两个整型的成员变量,各占4个字节大小,再加上一个虚函数指针,共计占12个字节;inheriter类继承了base类的两个成员变量以及虚函数表指针,因此大小与基类一致。如果inheriter多重继承自另外一个也包括了虚函数的基类,那么隐藏成员就包括了两个虚函数表指针。
- 重写函数的特征标必须与基类函数一致,否则将覆盖基类函数;
- 重写不同于重载。我对重载的理解是:同一个类,内部的同名函数具有不同的参数列表称为重载;重写则是派生类对基类同名函数的“本地改造”,要求函数特征标完全相同。当然,返回值类型不一定相同(可能会出现返回类型协变的特殊情况)。
虚基类
在c++中,派生类可以继承多个基类。问题在于:如果这多个基类又是继承自同一个基类时,那么派生类是不是需要多次继承这“同一个基类”中的内容?虚基类可以解决这个问题。
简而言之,虚基类可以使得从多个类(它们继承自一个类)中派生出的对象只继承一个对象。虚继承的写法如下:
class mytest:virtual public base
{
};
base称为mytest类的虚基类。假设base还是另外一个类mytest2的虚基类,对于多重继承mytest和mytest2的子类mytest3而言,base的部分只继承了一次。如下:
class base
{
int b;
public:
virtual void test(){ cout<<"基类方法!"<<endl; virtual ~base(){};
};
class mytest:virtual public base
{
};
class mytest2:virtual public base
{
};
class mytest3:public mytest,public mytest2
{
};
cout<<sizeof(mytest)<<endl;
cout<<sizeof(mytest2)<<endl;
cout<<sizeof(mytest3)<<endl;
mytest类与mytest2类的大小为什么是12?这是因为它们在虚继承自base类后,添加了一个隐藏的成员——指向虚基类的指针,占4个字节。而base类本身占8个字节,因此它们的大小均为12。而对非虚继承而言,是不需要这样的一个指针的。而mytest3类的大小为sizeof(base)+sizeof(mytest-base)+sizeof(mytest2-base),即16。
说明:
1.若一个类多重继承自具有同一个基类的派生类时,调用同名成员函数时会出现二义性。为了解决这个问题,可以通过作用域解析运算符澄清,或者在类中进行重新定义;
2.继承关系可能是非常繁复的。一个类可能多重继承自别的类,而它的父类也可能继承自别的类。当该类从不同的途径继承了两个或者更多的同名函数时,如果没有对类名限定为virtual,将导致二义性。当然,如果使用了虚基类,则不一定会导致二义性。编译器将选择继承路径上“最短”的父类成员函数加以调用。该规则与成员函数的访问控制权限并不矛盾。也就是说,不能因为具有更高调用优先级的成员函数的访问控制权限是"private",而转而去调用public型的较低优先级的同名成员函数。
纯虚函数
若一个类的成员函数被声明为纯虚函数,则意味着该类是ABC(Abstract Base Class,抽象基类),即只能被继承,而不能用来声明对象。纯虚函数通常需要在类声明的后面加上关键词“=0”。
当然,声明为纯虚函数并不意味着在实现文件中不可对其进行定义,只是意味着不可用抽象基类实现一个具体的对象。
friend
友元函数
在定义一个类的时候,可以把一些函数(包括全局函数和其他类的成员函数)声明为“友元”,这样那些函数就成为该类的友元函数,在友元函数内部就可以访问该类对象的私有成员了。
将全局函数声明为友元的写法如下:
friend 返回值类型 函数名(参数表);
将其他类的成员函数声明为友元的写法如下:
friend 返回值类型 其他类的类名::成员函数名(参数表);
但是,不能把其他类的私有成员函数声明为友元。
关于友元,看下面的程序示例。
#include<iostream>
using namespace std;
class CCar;
class CDriver
{
public:
void ModifyCar(CCar* pCar);
};
class CCar
{
private:
int price;
friend int MostExpensiveCar(CCar cars[], int total);
friend void CDriver::ModifyCar(CCar* pCar);
};
void CDriver::ModifyCar(CCar* pCar)
{
pCar->price += 1000;
}
int MostExpensiveCar(CCar cars[], int total)
{
int tmpMax = -1;
for (int i = 0; i<total; ++i)
if (cars[i].price > tmpMax)
tmpMax = cars[i].price;
return tmpMax;
}
int main()
{
return 0;
}
这个程序只是为了展示友元的用法,所以 main 函数什么也不做。
第 3 行声明了 CCar 类,CCar 类的定义在后面。之所以要提前声明,是因为 CDriver 类的定义中用到了 CCar 类型(第7行),而此时 CCar 类还没有定义,编译会报错。
不要第 3 行,而把 CCar 类的定义写在 CDriver 类的前面,是解决不了这个问题的,因为 CCar 类中也用到了 CDriver 类型(第14行),把 CCar 类的定义写在前面会导致第 14 行的 CDriver 因没有定义而报错。C++ 为此提供的解决办法是:可以简单地将一个类的名字提前声明,写法如下:
class 类名;
尽管可以提前声明,但是在一个类的定义出现之前,仍然不能有任何会导致该类对象被生成的语句。但使用该类的指针或引用是没有问题的。
第 13 行将全局函数 MostExpensiveCar 声明为 CCar 类的友元,因此在第 24 行可以访问 cars[i] 的私有成员 price。同理,第 14 行将 CDriver 类的 ModifyCar 成员函数声明为友元,因此在第 18 行可以访问 pCar 指针所指向的对象的私有成员变量 price。
友元类
一个类 A 可以将另一个类 B 声明为自己的友元,类 B 的所有成员函数就都可以访问类 A 对象的私有成员。在类定义中声明友元类的写法如下:
friend class 类名;
来看如下例程:
class CCar
{
private:
int price;
friend class CDriver;
};
class CDriver
{
public:
CCar myCar;
void ModifyCar()
{
myCar.price += 1000;
}
};
int main()
{
return 0;
}
第 5 行将 CDriver 声明为 CCar 的友元类。这条语句本来就是在声明 CDriver 是一个类,所以 CCar 类定义前面就不用声明 CDriver 类了。第 5 行使得 CDriver 类的所有成员函数都能访问 CCar 对象的私有成员。如果没有第 5 行,第 13 行对 myCar 私有成员 price 的访问就会导致编译错误。
一般来说,类 A 将类 B 声明为友元类,则类 B 最好从逻辑上和类 A 有比较接近的关系。例如上面的例子,CDriver 代表司机,CCar 代表车,司机拥有车,所以 CDriver 类和 CCar 类从逻辑上来讲关系比较密切,把 CDriver 类声明为 CCar 类的友元比较合理。
友元关系在类之间不能传递,即类 A 是类 B 的友元,类 B 是类 C 的友元,并不能导出类 A 是类 C 的友元。“咱俩是朋友,所以你的朋友就是我的朋友”这句话在 C++ 的友元关系上 不成立。
参考
命名空间
inline函数
mutable和volatile
static
explicit
虚函数
友元
内存分配
本文内容由网友自发贡献,版权归原作者所有,本站不承担相应法律责任。如您发现有涉嫌抄袭侵权的内容,请联系:hwhale#tublm.com(使用前将#替换为@)