char数组和指针问题

这个问题是C++基础问题中相当折腾人的一个,死记硬背解决不了根本问题,记住还是要忘,需要仔细研究其本质。

这两种方式就是数组和指针的方式:

1
2
char a[6] = "abcde";
char *b = "abcde";

第一行声明了并初始化了一个char数组,第二行是声明char指针b,指向了常量字符串。其中a是数组的首地址,a和b的地址一定不同。

千万不能说数组名是指针,可以用sizeof来否定:

1
2
char a[]="abcde";
cout<<sizeof(a)<<endl;

如果a是个指针,那么结果是4,但结果是6.

数组不能被直接复制,所以当数组名作为函数参数的时候,要么就是数组的引用,要么就是指向第一个元素的指针,他们的值是相等的。当你对一个数组做&的时候,他提取的是指向数组的指针,然后仍然可以隐式转换成指向第一个元素的指针,而且它们的值是相等的。

这样的代码是错的:

1
2
char a[6] = "abcde";
a[6] = "asdfge";

只有声明里才能用a[6],这就好比int a[6]={1,2,3,4,5,6};,但不能再用a[6]={5,6,7,8,9,0};。应该用a[0]='A';

这样的代码是正确的:

1
2
3
char a[]="abcde";
char *b;
b = a;

b是指针变量,指向了数组的首地址。

这样是错的:

1
2
3
char *a="abcde";  或者  char a[]="abcde";
char b[6];
b = a;

实际上是上一种情况的相反,报错error: incompatible types in assignment of 'char*' to 'char [6]'因为不存在一个隐式转换使得 char 被转换成 char[]。这个问题比较关键,我们可以把数组名b理解成一个常量指针,它不能指向其他地址,但指向的字符串可以改变。但是注意只是这么理解而已,数组名并不真的是常量指针。同样的,b++;也是错的。
从另一个角度来看,*数组名做函数参数时会退化为指针
,这里没有退化为指针的条件,所以b不能当指针变量用。

这样也是错的:

1
2
char a[6];
a = "abcde";

a是数组的首地址,怎么把字符串常量赋给它?

再看这种情况:

1
2
3
char *a, *b;
a = "abcde";
b = "abcde";

a和b的值不一定相同,也就是不一定是同一个地址,这取决于编译器的行为。

对于char指针和数组,以下操作都是可行的。

1
2
3
4
5
6
7
8
9
10
11
const char* p="abcd";	//在常量区,应当加const,否则编译器会报警
// char p[]="abcd"; // 在stack
cout<<p<<endl; // abcd
cout<<&(*p)<<endl; //abcd
cout<<*p<<endl; // a
cout<<&p<<endl; // 0x62fe9c

cout<<p+2<<endl; //cd
cout<<*(p+2)<<endl; //c
cout<<*p+2<<endl; //99
cout<<p[2]<<endl; //c

但下面操作仅适用于char数组,不能用于指针,指针指向的是常量:

1
//p[0]='A';

对于数组char p[]="abcd";,可以使用p[2],这是因为数组名在这里退化为指针,p转为指向数组首元素的char*类型。也就是说指针本身就可以用[],反而是数组名需要先转换为指针才能用[]。看下面的例子:
1
2
3
4
5
6
int b[5] = {1,2,3,4,5};
int *f=b;
cout<<f[2]<<endl; // 3
f[2]=0;
cout<<f[2]<<endl; // 0
cout<<b[2]<<endl; // 0

对于常量字符串,都可以用数组下标,这种做法比较少见:

1
cout<<"abcd"[2];     //c


new与delete

对类类型而言,new运算是先分配内存再执行构造函数,delete是先执行析构函数再释放内存

对array的用法

我们都知道new与delete经常这样用:

1
2
3
4
5
int* a = new int(10);
delete a;

int* b = new int[10];
delete []b;

如果第二种情况改用delete b;会不会有内存泄漏? 答案是仍然不会,分配简单类型内存时,内存大小已经确定,系统可以记忆并且进行管理,在析构时,系统并不会调用析构函数。它直接通过指针可以获取实际分配的内存空间,哪怕是一个数组内存空间。

但是对于类对象就不能这样用了,看下面的类:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
class Base
{
public:
Base()
{
std::cout<<"基类构造 "<<this<<endl;
}
virtual ~Base()
{
std::cout<<"基类析构"<<this<<endl;
}
};
Base* pb = new Base[5];
delete pb;

运行结果如下,有5个构造,但只有1个析构函数,而且从this指针来看,是数组第一个元素的析构函数:
1
2
3
4
5
6
7
基类构造 0xe118d4
基类构造 0xe118ec
基类构造 0xe11904
基类构造 0xe1191c
基类构造 0xe11934

基类析构 0xe118d4

delete pb只用来释放pb指向的内存和一个析构。delete[] pb用来释放指针指向的内存,还逐一调用数组中每个对象的析构。 所以为了编程规范,不管对简单类型还是类类型,都要用delete []pb的形式。

与malloc/free的区别

  • new/delete用于C++中的动态内存分配; malloc/free仅用于C环境,用于类类型时,不会运行构造析构函数

  • new/delete不必指定分配内存大小,malloc/free必须指定

  • new返回的是指定对象的指针,而malloc返回的是void*malloc的返回值一般都需要进行类型转化。

  • new是一个操作符可以重载,malloc是一个库函数

比如:

1
2
Base* b = (Base*)malloc(12);
free(b);

12是随便指定的,结果不运行构造和析构函数,而且如果中间运行成员函数,程序会崩溃。 所以这种代码没有任何意义


函数在main之前或之后运行
  • C++中,全局对象的构造函数在main之前运行,析构函数在main之后运行。
  • 类静态变量的初始化在main之前,静态函数不行
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
class Base
{
public:
Base()
{
std::cout<<"基类构造"<<endl;
}
~Base()
{
std::cout<<"基类析构"<<endl;
}
static int get()
{
std::cout<<"get()"<<endl;
return 55;
}
static int count;
}

// main.cpp
Base b;
// int Base::count = Base::get(); 错误,这里不能调静态函数
int main()
{
std::cout<<"main "<<endl;
return 0;
}

运行结果:

1
2
3
4
基类构造
get()
main
基类析构

gcc中使用attribute关键字,声明constructor和destructor函数:

1
2
3
4
5
6
7
__attribute__((constructor)) void before_main() { 
printf("before main\n");
}

__attribute__((destructor)) void after_main() {
printf("after main\n");
}

如何在程序退出时运行函数

很多时候我们需要在程序退出的时候做一些诸如释放资源的操作,但程序退出的方式有很多种,比如main()函数运行结束、在程序的某个地方用exit()结束程序、用户通过Ctrl+C或Ctrl+break操作来终止程序等等,因此需要有一种与程序退出方式无关的方法,在退出时执行某函数。方法就是用atexit()函数来注册程序正常终止时要被调用的函数。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
#include <cstdlib>

void atexit_handler_1()
{
std::cout << "at exit #1\n";
}

void atexit_handler_2()
{
std::cout << "at exit #2\n";
}

QApplication a(argc, argv);

const int result_1 = std::atexit(atexit_handler_1);
const int result_2 = std::atexit(atexit_handler_2);

if ((result_1 != 0) || (result_2 != 0)) {
std::cerr << "Registration failed\n";
return EXIT_FAILURE;
}
MainWindow w;
w.show();
return a.exec();

atexit执行成功,返回0,否则返回非0.

当程序正常终止(调用exit()或者由main函数返回)时,调用atexit()参数中指定的函数。


运算符重载(二)

以一个Point类为例,重载几个运算符,代码如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
class Point
{
public:
Point(int x=0,int y=0)
{
arr[0] = x;
arr[1] = y;
}
void print()
{
cout<<"x: "<<arr[0]<<" y: "<<arr[1]<<endl;
}

int& operator [](int num)
{
assert(num==1 || num==0);
if(num==0)
return arr[0];
else if(num==1)
return arr[1];
}
Point& operator -()
{
return Point(-arr[0],-arr[1]);
}
Point& operator --()
{
return Point(arr[0]-1,arr[1]-1);
}
Point& operator ++()
{
return Point(arr[0]+1,arr[1]+1);
}
Point& operator +(Point& p)
{
return Point(arr[0]+p.arr[0], arr[1]+p.arr[1]);
}
Point& operator -(Point& p)
{
return Point(arr[0] - p.arr[0], arr[1] - p.arr[1]);
}
bool operator ==(const Point& p)
{
return ((arr[0]==p.arr[0]) && (arr[1]==p.arr[1]) )
}
private:
int arr[2];
};

有一个数组做成员变量,构造函数给数组赋值。
首先是一元运算符- -- ++,显然是无参数的。返回值应当是Point&,函数也容易理解。
二元运算符加法和减法及相等也简单,有一个参数而已。其实这三个运算符由于是双目的,最好按友元重载。

下标运算符重载的声明必须是返回类型& operator [](参数),只能作为类成员函数,不能做友元。

调用:

1
2
3
4
5
6
7
8
9
10
11
12
13
Point p(1,4);
//改变 p
p[0] = 7;
p[1] = 9;
Point p1 = -p;
Point p2(4,12);
Point p3 = p - p2;
if(p2==p3)
cout<<"equal"<<endl;
else
cout<<"not equal"<<endl;
Point p4 = ++p3;
Point p5 = --p3;

参考:C++ 运算符重载


运算符重载(一)

不能重载的运算符:sizeof .(类成员访问) .*(类成员指针访问) :: ?:(三元运算符)。记住只有sizeof和带.的运算符不能重载。

运算符重载有两种方式:成员函数和友元函数。成员函数的形式比较简单,就是在类里面定义了一个与操作符相关的函数。友元函数因为没有this指针,所以形参会多一个。

对运算符重载通常是这样的:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
class Base
{
public:
Base();
explicit Base(int a)
{
m = a;
}
Base operator +(Base& b) //可以是成员函数,也可以是友元
{
Base temp;
temp.m = this->m + b.m;
return temp;
}
friend std::ostream& operator<<(ostream& out, Base& b); //只能是友元
private:
int m;
};

std::ostream& operator<<(ostream& out, Base& b)
{
out<<b.m;
return out;
}

调用:
1
2
3
4
Base b1(3);
Base b2(9);
Base b3 = b1+b2;
std::cout<<b3<<endl;

输入输出运算符重载不能做类的成员函数, 因为平时的输出命令是cout<<b;,实际是cout.operator<<b形式的,如果做成员函数,就变成了b.operator<<cout的形式。

C++ Primer的解释是:假设输入输出运算符是某个类的成员,则它们也必须是istream或ostream的成员。然而这两个类属于标准库,并且我们无法给标准库中的类添加任何成员。

Qt的<<重载也是类似的方法:

1
2
3
4
5
6
//输出QLineF的两点坐标
QDataStream &operator<<(QDataStream &stream, const QLineF &line)
{
stream << line.p1() << line.p2();
return stream;
}

  • 单目运算符最好重载为类的成员函数;双目运算符则最好重载为类的友元函数。
  • 以下一些双目运算符不能重载为类的友元函数:=、()、[]、->。
  • 类型转换运算符只能以成员函数方式重载
  • 流运算符只能以友元的方式重载

拷贝构造函数

基本规则

  • copy构造函数是一种特殊的构造函数,函数的名称必须和类名称一致,没有返回值。它必须的一个参数是本类型的一个引用变量,如果形参是对象做值传递, 将实参传进函数时, 我们实际是拷贝一个副本,这样又要调用拷贝构造函数, 层层递归, 会把栈堆满。类中可以存在多个copy构造函数。

  • 编译器会自动生成默认copy构造函数,这个构造函数很简单,仅仅使用“老对象”的数据成员的值对“新对象”的数据成员逐个进行赋值,也就是浅拷贝

  • 默认copy构造函数不处理静态变量。如果静态成员变量在构造、析构实例的时候需要修改,那么通常需要手工实现copy构造函数和重载赋值运算符。

  • 如果对象存在了动态成员,那么需要手动实现析构函数,也就需要手动实现copy构造函数,因为默认copy构造函数使用的是浅拷贝,要改用深拷贝。

  • 如果派生类没有自定义拷贝构造函数,它在拷贝时,会调用基类的copy构造函数。如果两个类都自定义copy构造函数,那么只调用派生类的。

  • copy构造函数也要对常成员变量进行列表初始化

  • 基类定义了带参数的构造函数,派生类没有定义任何带参数的构造函数,则不能直接调用基类的带参构造函数,程序编译不通过

深拷贝

浅拷贝实际是对变量的引用,深拷贝是对类成员复制并重新分配内存, 二者的最大区别在于是否手动分配内存

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
class Base
{
public:
Base();
explicit Base(int a);
virtual ~Base();
Base(const Base& obj);
private:
int m;
// 最好用智能指针
int *p;
};
Base::Base(int a):
m(a)
{
p = new int(100); // p内存分配在stack
}

Base::~Base()
{
if(p)
{
delete p;
p = NULL;
}
}
Base::Base(const Base &obj):
m(0),
p(new int(100))
{
std::cout<<"copy构造函数"<<endl;
m = obj.m;
// 动态分配的内存必须自定义copy构造函数,浅拷贝不会处理
int* temp = new int;
*temp = *(obj.p);
this->p = temp;
}
//调用
Base b1(15);
Base b2(b1);

不能不处理p。假如copy构造函数中没有对p分配内存,编译正确,但运行时b2析构会出现问题。因为默认拷贝执行浅拷贝,把b2里的p也指向了b1里的p,二者地址相同,结果会出现二次析构,内存泄漏。

我用Creator试验二次析构,发现程序结束时报错 program has unexpectedly finished ,再次运行时Qt先报信息Fault tolerant heap shim applied to current process.,这就是内存泄漏造成的,按照这个方法解决

标准化容器使用insert、push、assign等成员增加元素的时候也会调用拷贝构造函数

禁用拷贝

禁用原因主要是两个:

  1. 浅拷贝问题,也就是上面提到的二次析构。
  2. 自定义了基类和派生类的copy构造函数,但派生类对象拷贝时,调用了派生类的拷贝,没有调用自定义的基类拷贝而是调用默认的基类拷贝。这样可能造成不安全,比如出现二次析构问题时,因为不会调用我们自定义的基类深拷贝,还是默认的浅拷贝。

Effective C++条款6规定,如果不想用编译器自动生成的函数,就应该明确拒绝。方法一般有三种:

  1. C++11对函数声明加delete关键字:Base(const Base& obj) = delete;,不必有函数体,这时再调用拷贝构造会报错
  2. 最简单的方法是将copy构造函数声明为private
  3. 条款6给出了更好的处理方法:创建一个基类,声明copy构造函数,但访问权限是private,使用的类都继承自这个基类。默认copy构造函数会自动调用基类的copy构造函数,而基类的copy构造函数是private,那么它无法访问,也就无法正常生成copy构造函数。

Qt就是这样做的,QObject定义中有这样一段,三条都利用了:

1
2
3
4
5
6
private:
Q_DISABLE_COPY(QMainWindow)

#define Q_DISABLE_COPY(Class) \
Class(const Class &) Q_DECL_EQ_DELETE;\
Class &operator=(const Class &) Q_DECL_EQ_DELETE;

类的不可拷贝特性是可以继承的,凡是继承自QObject的类都不能使用copy构造函数和赋值运算符

有没有定义派生类copy构造函数的情况的不同结果

先是没有定义派生类copy构造函数的情况:

1
2
Derived f;
Derived ff(f);

运行结果是这样:

1
2
3
4
5
6
7
8
Base constrct      0x75fd20
Derived construct 0x75fd20
Base copy constrct 0x75fd10
*************
Derived deconstruct 0x75fd10
Base deconstrct 0x75fd10
Derived deconstruct 0x75fd20
Base deconstrct 0x75fd20

对于副本的对象,只调用了基类copy构造函数。


然后是定义的情况,运行结果是这样:

先是f的基类构造和派生类构造,然后进入ff,这里的对象是个副本,所以this指针的地址不同了, 先是基类构造然后是派生类拷贝构造, 销毁时倒没什么特别。

这样看来, 派生类的copy构造函数可以尽量不定义。

参考:
详解copy构造函数
为什么很多人禁用拷贝(复制)构造函数


结构体与类的字节对齐(终极方案,简单易懂)

先记住常用类型在32和64位的字节

类型 32位 64位
char 1 1
int 4 4
short 2 2
float 4 4
double 8 8
指针 4 8

只有指针在64位时不同,是8。函数指针的typedef声明不参与计算。枚举类型占内存4字节。
另外注意:gcc中没有要求结构体大小是最大对象的整数倍。

字节对齐

终于搞清楚结构体的字节对齐怎么计算了,看了那么多国内博客,大部分都不靠谱,要不然就是不知所云,最后看了一个印度三哥的视频讲解,没用3分钟就明白了。其实就一条规则:计算时按最大成员的大小进行逐个判断,有需要就补位

直接看几个例子:

1
2
3
4
5
6
typedef struct bb
{
int i; //4
double w; //8
float h; //4
};

我们以为它在内存中是这样的: iiii wwwwwwww hhhh 其实是这样的:iiii ---- wwwwwwww hhhh ----
最大的double占8个,从左向右,每8个为一组,编译器无法把iiii wwww一起处理,那样就把double截断了,所以给int补4位。同理float补4位。总共24.

1
2
3
4
5
6
struct s1{
char c; //1
int i; // 4
short f; // 2
double v; // 8
};

原本是这样:c iiii ff vvvvvvvv,从左向右按8补齐,应当是:c--- iiii ff------ vvvvvvvv。c和i总共5,给c补3位就行。f没法和v组合,只能补6位,总共24.

1
2
3
4
5
6
struct s1{
short f; //2
char c[3]; //3
int i; //4
double v; //8
};

原来是:ff ccc iiii vvvvvvvv,2+3不足8,2+3+4超过了8,所以给f补3位,然后i补4位,也就是2+3+3+4+4+8=24

最后来个特殊的,计算N的大小:

1
2
3
4
5
6
7
8
9
struct Node{
char c;
int i;
char p;
};
struct N{
Node n; //12
int x; //4
};

按上面的方法可知Node占12,那么按上面的方法,N是不是该占24?错了,在N里的Node应该按cccc iiii pppp处理,这样N就占16.

1
2
3
4
5
6
7
8
9
10
11
12
13
struct s1{
char c; //1
int i; // 4
short f; // 2
double v; // 8
};

struct s2{
char c; //1
short f; // 2
int i; // 4
double v; // 8
};

第一个的大小是24,第二个是16

#pragma pack (n)

这条预处理命令也好理解了,只要把上面规则中最大变量的大小换成n就行,注意假设结构体中最大元素占内存m,当n如果超过m是不起作用的。

类的sizeof计算

  1. 类的大小为类的非静态成员数据的类型大小之和,也就是说静态成员数据不作考虑。
  2. 普通成员函数和构造函数不影响sizeof的计算
  3. 虚函数由于虚指针的存在,所以要占据一个指针大小,也就是4字节,无论多少个虚函数
  4. 类的总大小也遵守字节对齐规则。

将类定义如下:

1
2
3
4
5
6
7
8
9
10
11
12
class Base
{
public:
Base();
explicit Base(int a);
virtual ~Base();
void test();
virtual void test_virtual();
private:
void foo();
protected:
int m;

执行sizeof的结果是8,如果把虚析构函数去掉就变成4,再把int m去掉就变成了1,实际是空类,但是空类实例化也要在内存占用地址,由编译器添加一个字节以区分不同对象。


回调函数

之前对回调函数理解一直不到位,需要深入分析一下。
一般函数都是系统提供或程序员自定义的,让程序员使用的。但回调函数恰恰相反,它是程序员定义(注册),在特定条件(常常是用户触发)发生时由系统API调用的,是通过函数指针实现调用的。函数定义在高层,调用在底层。

Linux信号处理机制就是利用回调函数实现的,例如signaction某个形参就有一个成员是函数指针。

1
2
3
4
5
6
7
8
9
10
11
12
void func(int n)
{
printf("signal %d catched !\n",n);
}
int main()
{
struct sigaction act;
act.sa_handler = func;
sigaddset(&act.sa_mask,SIGQUIT);
act.sa_flags = 0;
sigaction(SIGINT,&act,NULL);
}

当程序运行后,按Ctrl+C会发送SIGINT信号,然后内核调用函数func,输出文本。

类的成员函数做回调函数

由于this指针的作用,使得将一个CALLBACK型的成员函数作为回调函数安装时就会因为隐含的this指针使得函数参数个数不匹配,从而导致回调函数安装失败。定义类成员函数时,在该函数前加CALLBACK即可将其定义为回调函数。

  1. 类的静态成员函数实现回调函数
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
void func(int sig)
{
cout << endl;
cout << "signal: "<<sig<<endl;
if(sig == 15)
cout << "SIGTERM"<<endl;
else
cout << "SIGINT"<<endl;
exit(0);
}

class Foo
{
public:
static void func(int sig)
{
cout << endl;
cout << "signal: "<<sig<<endl;
if(sig == 15)
cout << "receive signal SIGTERM"<<endl;

exit(0);
}
};

int main()
{
signal(SIGINT, func);
signal(SIGTERM, Foo::func); // 第二个参数也可以是func
while(1) // 设法阻塞
sleep(1);
return 0;
}

从终端启动程序,会阻塞。按下Ctrl+C,会触发SIGINT信号。执行pkill命令,会触发SIGTERM信号。


this指针

this指针指向对象的地址,本身是一个常量指针MyClass *const this,也就是不能改变指向的对象。

this指针是在创建对象前就有了,在编译时刻已经确定,this指针放在栈上。当一个对象创建后,整个程序运行期间只有一个this指针.

我是这样理解类和this指针的:类相当于房子的户型,根据这个户型可以造出很多房子,这就相当于对象。每个房子的地址不同,这就相当于内存地址。当你进入一个房子后,你可以看见桌子、椅子、地板等,但是房子你是看不到全貌了。this就是房子里面的一个标识,说明了房子的地址,但这个标识又不占房子空间。

this指针不属于对象本身的一部分,不会影响sizeof作用。 顺便一提,一个空的类,sizeof的大小是1

this指针是编译器默认传给类中非静态函数的隐含形参,其作用域在非静态成员函数的函数体内。
在类的赋值运算符重载函数中,我们可以一般使用*this作为当前对象返回。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
class Base
{
public:
Base();
void test();
void test_pub();
}
//相当于void Base::test(Base* const this)
void Base::test()
{
std::cout<<this<<endl;
cout<<"base test"<<endl;
}
void Base::test_pub()
{
std::cout<<this<<endl;
cout<<"base test_pub"<<endl;
}

调用两函数的结果:

1
2
3
4
00DDF9A0
base test
00DDF9A0
base test_pub

也就是说运行时只有一个this指针。


类的静态变量和静态函数

如果有N个同类的对象,那么每一个对象都分别有自己的成员变量,不同对象的成员变量各自有值,互不相干。但是有时我们希望有某一个或几个成员变量为所有对象共有,这样可以实现数据共享。

可以使用全局变量,但用全局变量的安全性得不到保证,由于在各处都可以自由地修改全局变量的值,很有可能偶然失误,因此在实际开发中很少使用全局变量。

静态变量

  • 对于类的静态成员变量,只有static const int类型和 enum 类型能在类里面初始化,其他只能在.cpp里初始化,但不能在类体内初始化,因为静态数据成员为类的各个对象共享,否则每次创建一个类的对象则静态数据成员都要被重新初始化。

  • 静态成员函数和静态变量在类体外初始化时,无须加static关键字,否则是错误的。

  • static成员变量的内存空间是在初始化时分配,程序结束才释放,跟类对象的销毁无关。

  • 静态变量不参与sizeof计算,因为它不占用对象的内存

  • 静态成员仍然遵循public,private,protected访问准则。

静态函数

  • 静态成员函数只能调用静态变量,因为没有this指针。 设计它的初衷是把类名当成namespace用,控制类内的static变量。

  • 静态成员函数仍然遵循访问等级,但最好是public,否则不能直接用类名::调用

  • 非静态成员函数可以任意地访问静态成员函数和静态数据成员。

  • 静态成员函数不能声明为虚函数,编译直接报错

  • 静态成员函数与成员函数不能同名同参数,也就是静态和非静态函数不能重载,否则编译器不知调用哪个

举例:

1
2
3
4
5
6
7
8
9
10
11
12
// 头文件
class Obj
{
private:
Obj() {}
static Obj* instance;

public:
static Obj* getInstance();
static const int n = 12;
static int n;
};

1
2
3
4
5
6
7
8
9
10
11
//源文件
Obj* Obj::instance=0; //类外定义
int Obj::n = 4; //类外定义
Obj* Obj::getInstance()
{
if(!instance)
{
instance = new Obj();
}
return instance;
}

参考:
Essential C++ 115页