一、从C到C++

  1、语法升级

    引用

C++的函数使用 类型+& 代替 类型+*的作用

例如

void swp(int &a, int &b)
{
	a++;
	b++;
}

int main()
{
	int c = 0;
	int d = 0;
	swp(c, d);
}
1
2
3
4
5
6
7
8
9
10
11
12

c与d的值变为 1；

---

    默认参数

函数参数可以设定默认值

例如：

void debug(const char *ptr = "---------------")
{
	printf("%s\n", ptr);
}

int main()
{
	debug();
	debug("hello");
	debug("world");
}
1
2
3
4
5
6
7
8
9
10
11

---

    函数重载

函数可以使用相同的名称，但参数必须不同

例如：

int  cmp(int  data1, int  data2 );  
int  cmp(const char *str1, const char *str2);
1
2

---

    堆内存

使用 new 创建内存，使用 delete 注销内存

例如：

	char *p = new char[20];
	delete []p;

	int *q = new int;
	delete []q;
1
2
3
4
5

---

  2、概念与思想升级（了解）

面向对象的编程

• 名字空间： namespace NAME1{ }
• 类：class
• 类、对象、封装，继承、组合等

C++也可以进行面向过程的编程，但是更适合面向对象的编程

---

二、类与对象

  1、类的声明

class 类名
{ 
private:        //只能在类内部使用，外部无法调用
	私有的数据;
	成员函数;
public:        //可以在内外部调用
	公用的数据;    
	成员函数;
protected:
	保护的数据;
	成员函数
};
1
2
3
4
5
6
7
8
9
10
11
12

例如：

#include <stdio.h>

class A
{
public:
	void show()
	{
		printf("xxxxxxxxxxxxx\n");
	}

	void setdata(int data)  //类的函数内部实现
	{
		a = data;  //私有成员类的内部使用
	}

	int getdata(void);
private:
	int a;
};

int A::getdata(void)  //类的函数外部实现
{
	return a;
}

int main()
{
	A x;   //创建对象

	x.setdata(100);  //成员是公共部分可以调用
	//x.a = 100;  //成员是私有部分，无法调用

	printf("%d\n", x.getdata() );

	x.show();
}
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

---

  2、成员函数

• 构造函数（类创建时，自动调用）
• 析构函数（类注销时，自动调用）
• 普通成员函数（函数）

例如：

class A
{
public:
	A()  //默认构造函数，没有时自动创建但是什么也不会做
	{
		printf("A()\n");
		p = new char[10];
		strcpy(p, "hello");

		printf("p: %s\n", p);
		printf("p: %s\n", this->p);
		//函数参数名字与类成员变量名字相同，采用this表示类成员变量
	}
	
	A(int a) //带参数构造函数，默认构造函数没写时，必须使用带参数构造函数
	{

	}
	
	A(const A &x)  //拷贝构造函数,对象被复制时自动调用
	{
		printf("A(const A &x)\n");
		p = new char[10];
		strcpy(p, x.p);	
	}

	~A()  //析构函数
	{
		printf("~A()\n");
		delete [] p;
	}

private:
	char *p;
};

int main()
{
	A x;
	
	A y = x;  
//对象复制，只复制数据与内容，不会调用默认构造函数与带参数构造函数

	A a(10); //显式传参
	A b = 10; //隐式传参，效果同上
}
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

---

  3、常成员、常对象

const 数据成员只在某个对象生存期内是常量，而对于整个类而言却是可变的

C++推荐const而不用#define

例如：

//常数据成员（构造函数初始化表赋值）
class A
{
public:  
	A():x(100) 
	{
	 
	}
	const int x;
}
1
2
3
4
5
6
7
8
9
10

常成员函数
void  func() const;
1
2

常对象
const A a;
1
2

---

  4、静态成员

成员属于类，不属于对象

例如：

//静态成员的申明
static int x;
static const int x = 10; 
//静态数据成员初始化
//类外： static int  A::x = 10;
1
2
3
4
5

//静态成员函数
static void func(); //能访问静态成员
//调用方法 A::func();
1
2
3

class A{
public:
	static void func(void)
	{
		printf("xxxxxxxxx\n");
	}

	static int data;
};

int A::data = 10;

int main()
{
	A a;
	a.func();
	A::func();

	A x;
	x.data = 100;
	printf("x.data = %d\n", x.data);

	A::data = 1000;

	printf("x.data = %d\n", x.data);
}
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

---

  5、友元

申明为 友元 可以调用类中的成员

• 友元类
  friend class B;
• 友元函数
  friend void func();
• 友元成员函数
  friend void B::func();

例如：

class A;
class B
{
public:
	void printfA(A &x);	
};

class A
{
public:
	A()
	{
		x = 100;
	}
//	friend class B;
	friend void B::printfA(A &x);
private:
	int x;
};

void B::printfA(A &x)
{
	printf("%d\n", x.x);
}

int main()
{
	B b;
	b.printfA(a);
}
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

---