type -a 命令可以查看某个shell命令的含义，对alias也适用

echo带颜色的文本

需要使用参数-e，格式为echo -e "\033[字背景颜色；文字颜色m字符串\033[0m"，比如"\033[45;5m 闪烁效果 \033[0m"

1
2
3
4
5
6

echo -e "\033[40;37m 黑底白字 \033[0m"
echo -e "\033[41;37m 红底白字 \033[0m" 
echo -e "\033[42;37m 绿底白字 \033[0m" 
echo -e "\033[43;37m 黄底白字 \033[0m" 
echo -e "\033[44;37m 蓝底白字 \033[0m" 
echo -e "\033[45;37m 紫底白字 \033[0m" 

\033[5m 闪烁效果，这个以前不知道

1
2
3
4
5
6
7
8
9

字背景颜色范围: 40--49                   字颜色: 30--39 
        40: 黑                         30: 黑 
        41:红                          31: 红 
        42:绿                          32: 绿 
        43:黄                          33: 黄 
        44:蓝                          34: 蓝 
        45:紫                          35: 紫 
        46:深绿                        36: 深绿 
        47:白色                        37: 白色 

对shell脚本进行语法检查

1

bash -n script_name.sh         //   -n选项只做语法检查，而不执行脚本。

例如，检查结果可能是这样：

1
2
3

# bash -n t.sh 
t.sh: line 6: syntax error in conditional expression: unexpected token `;'
t.sh: line 6: syntax error near `;'

连续执行命令

连续执行shell命令有三种情况:

• 用分号;间隔，会一直执行，无论命令对错。 echo abc; echo 123
• 用&&间隔，执行到错误命令会停止。echo abc && adf && echo 123
• 用||间隔，执行到正确命令会停止。

二元比较操作符，比较变量或者比较数字.

整数比较

1
2
3
4
5
6

-eq 等于        if [ "$a" -eq "$b" ] 
-ne 不等于      if [ "$a" -ne "$b" ] 
-gt 大于        if [ "$a" -gt "$b" ] 
-ge 大于等于     if [ "$a" -ge "$b" ] 
-lt 小于        if [ "$a" -lt "$b" ] 
-le 小于等于     if [ "$a" -le "$b" ] 

比如 $a -eq 10

字符串比较

1
2

= 等于        if [ "$a" = "$b" ] 
== 等于       if [ "$a" == "$b" ],与=等价

参考: shell脚本 if语句

字符串条件判断

1
2
3
4

if [ "$net" = "0" ]
then
    echo "local"
fi

注意：

• 左右方括号都要留空位，if后面也要有空位
• Shell下使用等号赋值时，左右两边不能有空位
• 一个等号和两个等号都可以
• then要另起一行，以if开头，以fi结尾

查找字符串

grep -r "struct event_base" -n
在当前目录查找字符串，找到后返回文件和对应的行

空格的有和没有

定义变量时, =号的两边不可以留空格

1

gender=femal

1

if [ $gender = femal ]; then

条件测试的内容,如果是字符串比较的话, 比较符号两边要留空格

1

if [ $gender = femal ]; then

如果if 和 then写在同一行, 那么,注意, then的前面要跟上 ; 号.如果 then 换行写, 那么也没问题.

1
2

if [ $gender = femal ]
then

命令和其后的参数或对象之间一定要有空格

1

if [ -x"~/Workspace/shell/a.sh" ];then

取字符串的某一段

1
2
3
4
5
6
7

#/bin/bash -e

ip="192.168.0.123"
net=$(cut -d'.' -f3<<<"192.162.0.123")	  # 3个<
sub=$(echo $ip | cut -c1-7)		# -c 一般用于文件，比如 cut -c1-4 test.txt
echo $net
echo $sub

结果是:

1
2

0
192.168

使用awk的内建函数：

1
2
3

hostname -I | awk '{split($0,a,".");print a[1],a[2],a[3],a[4]}'   # 192 168 0 123

hostname -I | awk '{print substr($0,0,4)}'		# 192.

列出当前目录下，最大的10个文件

ls -Slh | head

连接字符串

如果想要在变量后面添加字符，可以用以下方法：

1
2
3
4
5

$value1=home

$value2=${value1}"="    　# 用单引号也行

echo $value2

echo

echo换行

echo要支持同C语言一样的\转义功能，只需要加上参数-e

echo -e “\n” 就是换行
echo -e $(cat test.txt)
其中test.txt的内容:

1

aaa \nbbb

1
2

aaa
bbb

echo文本到文件

echo换行的文本

1
2
3

echo -e "Hello\nworld"
echo -e 'Hello\nworld'
echo Hello$'\n'world

echo $(cat 1.txt) > 2.txt可以把文件1的内容复制到文件2。但如果文件1每行结尾没有加\n，文件2的内容不会换行。另外这样会覆盖文件2原有的内容。如果不想覆盖，而是追加到文件2，只要把>改为>>即可

常用的代码如下:

1
2

Base b;
cout<<"hello"<<endl;

1
2
3

基类构造 0x62fe84
hello
基类析构0x62fe84

但是这样的代码就不同了：

1
2

Base();		// 匿名的临时对象
cout<<"hello"<<endl;

1
2
3

基类构造 0x62fe84
基类析构0x62fe84
hello

看这样的代码，是关于显式调用构造函数导致的成员变量未初始化问题:

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 CTest  
{
public:
    CTest()  
    {  
        m_a = 1;  
    }  
    CTest(int b)  
    {  
        m_b = b;  
        CTest();  
    }  
    ~CTest()  {}  
    void showA()
    {
        std::cout<<"a:"<<m_a;
    }
private:  
    int m_a;  
    int m_b;  
};

void main()  
{  
    CTest myTest(2);
    t.showA();
}

这样的代码也是有问题的:

1
2
3

Base b;
b.~Base();
cout<<"hello"<<endl;

结果是二次析构了:

1
2
3
4

基类构造 0x62fe84
基类析构 0x62fe84
hello
基类析构 0x62fe84

fprintf

原型：extern int fprintf (FILE *f,const char *s, ...);
可以将字符串输出到某文件中，但更常用的用法是:

1
2

fprintf(stdout,"Hello\n");	 //加换行
fprintf(stderr,"World!");

snprintf

int snprintf(char *restrict buf, size_t n, const char * restrict format, ...);
函数说明:最多从源串中拷贝n－1个字符到目标串中，然后再在后面加一个0。所以如果目标串的大小为n的话，将不会溢出。
函数返回值:若成功则返回欲写入的字符串长度，若出错则返回负值。

1
2
3
4
5
6
7
8
9

char s1[6] = "12345";
char s2[6] = "67890";
int res;
res = snprintf(s1,sizeof(s1),"abcdefg");	//写入长度大于原来长度，写入abcde和\0，要求6
printf("s1:%s, res:%d\n",s1,res);			//欲写入长度7，这个值是strlen，不包含\0
res = snprintf(s1,sizeof(s1),"abc");		//写入长度少于原来长度，则相当于替换
printf("s1:%s, res:%d\n",s1,res);
res = snprintf(s2,4,"%s","abcdefg");		//指定4，包含了\0
printf("s2:%s, res:%d\n",s2,res);

1
2
3

s1:abcde, res:7
s1:abc, res:3
s2:abc, res:7

sprintf

int sprintf(char *buffer, const char *format, [ argument] … )；
函数功能：把格式化的数据写入某个字符串缓冲区。

函数不安全，写入目标时不会考虑字符数组的大小，要存储的字符超过数组长度时，会导致数组越界，编译不报错但运行报错，所以都会推荐使用snprintf.

1
2
3
4
5
6

char s1[6] = "12345";
int res;
res = sprintf(s1, "%s","abcdefg");	 //超出原字符数组长度，不安全
printf("s1:%s, res:%d\n",s1,res);
res = sprintf(s1, "%s","abc");
printf("s1:%s, res:%d\n",s1,res);

1
2

s1:abcdef, res:7
s1:abc, res:3

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

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

1
2

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

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

1
2

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

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

这样的代码是错的:

1
2

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

这样的代码是正确的:

1
2
3

char a[]="abcde";
char *b;
b = a;

这样是错的:

1
2
3

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

这样也是错的:

1
2

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

再看这种情况：

1
2
3

char *a, *b;
a = "abcde"; 
b = "abcde";

对于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';

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是先执行析构函数再释放内存

对array的用法

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

1
2
3
4
5

int* a = new int(10);
delete a;

int* b = new int[10];
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;

1
2
3
4
5
6
7

基类构造 0xe118d4
基类构造 0xe118ec
基类构造 0xe11904
基类构造 0xe1191c
基类构造 0xe11934

基类析构 0xe118d4

与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);

• 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];
};

下标运算符重载的声明必须是返回类型& 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;

不能重载的运算符：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;

有没有定义派生类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

然后是定义的情况，运行结果是这样：

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

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

参考：
详解copy构造函数
为什么很多人禁用拷贝（复制）构造函数

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

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

字节对齐

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

直接看几个例子：

1
2
3
4
5
6

typedef struct bb
{
 int i;	     //4 
 double w;   //8
 float h;     //4
};

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
};

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;