C++ 认识和了解C++

1.在使用C++语言写代码的时候开头要用到的是：

#include<iostream>
using namespace std;

不可以写成这样：

#include iostream.h

（1）iostream是输入输出流类，
istream输入流类 cin >>
ostream输出流类 cout <<
（2）namespace是名空间，即命名空间
namespace是为了解决词穷的问题。
比如说有一个项目，有3个模块，需要3个人，三个人都写了排序函数 sort() sort() sort()，如果在C语言中，函数名不可以重复，在C++中就可以用namespace解决这一问题

namespace AA
{
	int sum = 0;
	void sort()
	{
		cout << "AA:sort" << endl;
	}
};
namespace BB
{
	int sum = 0;
	void sort()
	{
		cout << "BB:sort" << endl;
	}
};
namespace CC
{
	int sum = 0;
	void sort()
	{
		cout << "CC:sort" << endl;
	}
};
void main()
{
	using namespace AA;
	sort();
	BB::sort();
	CC::sort();
}

运行结果：

2.C语言和C++的区别
C语言：面向过程程序设计，体现的是编程思想，用流程图来体现
C++：面向对象程序设计，体现的是类的设计，用类图来体现
C语言可以解决问题，描述问题
C++是C语言的升级，可以更加方便的描述问题
3.struct 在C和C++中的区别
（1）在C中，结构体不能为空；C++中可以，在C++中，空结构体大小为1个字节
（2）在C中，结构体名就是结构体名；在C++中，作为类型名，可以直接定义变量
（3）在C++中，结构体也需要内存对齐
（4）在C中，结构体中不允许写函数，不允许有操作；在C++中允许

struct A
{
	char a[5];
	int b;
	void print() {}   //在C++中结构体中可以有操作
};
void main()
{
	A aa;    //在C++中结构体作为类型名可以直接定义变量
	cout << sizeof(A) << endl;
}

4.struct和class的区别
（1）struct可以实现和class一样的功能
（2）struct默认为public，class默认为private

struct AA
{
	int m_a;
	void print() { cout << m_a << endl; }
};
class BB
{
	int m_a;
	void print() { cout << m_a << endl; }
};
void main()
{
	AA a;
	a.m_a = 10;
	a.print();
	BB b;
	/*b.m_a = 20;
	b.print();*/    //这是错误的操作，class默认为private，成员BB::m_a不可以访问
}

5.三种变量类型：值类型，指针类型，引用类型
引用：引用只是一个实体的别名，它能通过改变当前的别名去改变实体，可以达到改变实体的目的。
指针类型和引用类型的区别
不同点：
（1）指针可以不初始化，引用必须初始化
（2）指针通常初始化为NULL，引用不能为空
（3）sizeof(指针)为4，sizeof(引用)实体大小
（4）指针可以指向其他变量，引用不能改变
（5）指针可以取*,引用不能
相同点：
都能改变我们当前所引用的或者指向的变量（实体）

void main()
{
	int a = 10;
	char c = '2';
	char* p = &c;  //定义一个char类型的指针，指向c
	char d = 'p';
	p = &d;    //改变指针的指向，让指针指向d
	cout << sizeof(p) << endl;
    int& b = a; //声明了引用b，是a的别名
	            //引用在声明的时候必须初始化
	//int& c = NULL;  //error  引用不可以初始化为NULL
	b = 30;   //把a的值改变为30
	cout << a << endl;
}

6.野指针不是NULL指针，是指向垃圾内存的指针
（1）野指针可能声明时候出现，比如说定义指针变量声明的时候没有初始化，指针就是野指针
（2）free或者delete之后，没有把指针赋值为NULL
7.四种swap函数

//在不同的时间里修改了不同的内存单元中的值
void swap1(int x, int y)
{
	int t = x;
	x = y;
	y = t;
}
//在不同的时间里修改了同一段内存单元中的内容
void swap2(int* x, int* y)
{
	int t = *x;
	*x = *y;//将y所指向的内存空间里面的内容赋值到x所指向的内存单元中
	*y = t;
}
void swap3(int* x, int* y)
{
	int* t = x;
	x = y;
	y = t;
}
void swap4(int& x, int& y)//x是a的别名,y是b的别名
{
	int t = x;
	x = y;
	y = t;
}
void main()
{
	int a = 10, b = 6;
	swap1(a, b);
	cout << "a  = " << a << "  b = " << b << endl;
	swap2(&a, &b);
	cout << "a  = " << a << "  b = " << b << endl;
	swap3(&a, &b);
	cout << "a  = " << a << "  b = " << b << endl;
	swap4(a, b);
	cout << "a  = " << a << "  b = " << b << endl;
}

运行结果：

8.函数重载-----是一种重载多态
（1）函数名相同，同一个作用域
（2）参数列表不同()，参数的个数，参数的类型，参数的顺序不同
（3）和返回值无关,不能光通过函数返回值确定重载
（4）const函数可以区别重载

struct AA
{
	void test() { cout << "AA::test" << endl; }
	void test()const { cout << "AA::test const" << endl; }
};
/*   error 不能构成重载
int test()
{

}
*/
void test()
{
	cout << "test" << endl;
}
void test(int a)
{
	cout << "test(int)" << endl;
}
void test(int a, int b)
{
	cout << "test(int,int)" << endl;
}
void test(int a, int b, int c)
{
	cout << "test(int,int,int)" << endl;
}
void main()
{
	test();
	test(1);
	test(2, 6);
	test(3, 4, 5);
}

运行结果：

【注意】
①结构体中的test()和第六行的test()可以同时存在，因为函数名不相同，结构体中的函数名是AA::test，第六行的函数名是test；但是不能构成重载，因为作用域不一样
②结构体中的test()和test()const可以构成重载
③下面的test()，test(int a)，test(int a,int b)，test(int a,int b,int c)这四个函数可以构成重载
④int test()和void test()不能构成重载，它两函数名相同，参数列表相同，不能同时存在，因为光通过函数返回值进行区分