[C++知识库]c++与c的区别

                                  c++与c的区别

一、头文件与命名空间
1.c++中的头文件的表示
创建源文件是.cpp 文件，头文件不变，依旧是.h文件
2.c++包含头文件的方式
包含自己的头文件
包含自己的头文件没有任何区别

          #include "myHead.h"

	           包含库目录
	              c语言中：采用原来的方式包含可以，可以用c++包含方式，去掉 .h 加个c(包含c语言中标准库的时候)

		          
#include <stdio.h>
#include <cstdio>//包含c语言中标准库的时候

                   iostream C++标准输入输出流的头文件

#include <iostream>//类似c语言中的stdio.h

3.命名空间
   语法

//1.基本创建空间方法
namespace 空间名
{
 int a;
    void print(){}
}
//2.学会访问命名空间中的东西
//2.1 用空间名限定去访问
int main()
{
 空间名::a=1001;
    空间名::print();
    return 0;
}

   命名空间这块需要学会的：
	1、基本创建空间方法
	2、学会访问方法（学会访问命名空间中的东西）
        用空间名限定去访问

	printf("%d\n",MM::a);
	printf("%d\n",GG::a);
	MM::print();
	GG::print();

	     命名空间的作用：可以增加标识符的使用率，C语言同一个作用域下不允许定义相同的标识符

//错误	1	error C2374: “a”: 重定义；多次初始化	c:\users\administrator\desktop\consoleapplication2\consoleapplication2\源.cpp	8	1	ConsoleApplication2
//int a = 1;
//int a = 2;

namespace MM
{
	int a;
}
namespace GG
{
	int a;
}

   空间中声明，外面实现，使用::作用域分辨符

namespace GG
{
	int a=2;
	void print();//空间中声明
}
//外面实现
//::作用域分辨符
void GG::print()
{
	printf("GG中的函数\n");
}

		作用域分辨符    ::，作用：空间名限定；类名限定(后面讲)；	用来标识全局变量
		

```cpp
int xx = 1;
int main()
{
	int xx = 2;
	printf("%d\n", xx);//采用的是就近原则
	printf("%d\n",::xx);//全局变量
	return 0;
}

	using语法：可以省略命名空间前缀的写法
	用法：using namespace 空间名;   //就可以省略当前的空间名

	using namespace MM;
	printf("%d\n", a);//MM中的东西
	print();

   使用using namespace 注意不要存在二义性问题（存在两个选择）。并且存在作用域，只在当前作用域下有效
   
   空间名的嵌套与空间内容访问

namespace A
{
    int aa=1;
	namespace B
    {
        int bb=1;
    }    
}
A::B::bb=1001;		//剥洋葱
using namespace A::B;
bb=1002;

二、基本输入和输出
1.包含标准输入输出的头文件

#include <iostream>

2.包含命名空间
	一般情况都会包含命名空间  using namespace std;（标准库中 的所有内容都是写在这个标准库中的）

#include <iostream>
using namespace std;

int main()
{

	return 0;
}

3.输出格式
	输出: cout<< 做输出
	C++支持C语言的格式控制字符
4.输入格式
	  输入: cin>>做输入
5.例子

#include <iostream>
#include <string>
//using namespace std;  一般都是写在这里，避免std的前缀使用
void testCinCout() 
{
 using namespace std;
 //1.基本变量打印不需要格式控制
 cout << "ILoveyou\n";
 char str[] = "ILoveyou\n";
 cout << str;
 int a = 1;
 float b = 1.1;
 cout << a;
 cout << b;
 cout << "\n";
 //2.如何一次性打印多个数据
 cout << a << "\t" << (int)b << "\n";
 cout << a << "\t" << int(b) << "\n";
 //C语言运算符的隐式转换都是一样的
 int aa = 1.111;
 //3.C++换行  endl替换\n的作用
 cout << "姓名" << endl;
 cout << "年龄" << endl;

 int iNum = 0;
 float fNum = 0.0f;  //默认小数是double
 //unsigned int uNum = 1u;
 //long int lNum = 1L;
 cout << "请输入一个整数，一个浮点数，一个字符串：";
 //一个一个处理
 //cin >> iNum;
 //cin >> fNum;
 //cin >> str;
 //一次处理多个
 cin >> iNum >> fNum >> str;
 cout << iNum << "\t" << fNum << "\t" << str << endl;
}

//输入的几个问题
//1.字符串输入空格问题
void  testStr() 
{
 using namespace std;
 char str[10] = "";
 cin >> str; //不带空格的输入
 cout << str;
 //fflush(stdin) //已被淘汰
 //setbuf(stdin,NULL);
 while (getchar() != '\n'); //字符和字符串输入前，做了输入
 char c;
 cin >> c;
 cout << c;
 //接受空格的输入--->了解
 cin.getline(str, 10); //gets_s(str, 10);
 cout.write(str, 10);
}
//2.关于命名空间std
void testNamespace()
{
 //当不加using namespace  std;
 std::cout << "没有写using namespace std" << std::endl;
 std::string str = "ILoveyou";
}

int main() 
{
 testStr();

 return 0;
}

基本变量打印不需要格式控制

cout << "ILoveyou\n";

	如何一次性打印多个数据

	//一个一个处理
	//cin >> iNum;
	//cin >> fNum;
	//cin >> str;
	//一次处理多个
	cin >> iNum >> fNum >> str;
	cout << iNum << "\t" << fNum << "\t" << str << endl;

	C语言运算符的隐式转换都是一样的

int aa = 1.111;

		C++换行  endl替换\n的作用
6.输入的几个问题
		字符串输入空格问题

char str[10] = "";

while (getchar() != '\n');		//字符和字符串输入前，做了输入

	  关于命名空间std

//当不加using namespace  std;
std::cout << "没有写using namespace std" << std::endl;

三、新数据类型
1.bool类型
占用内存是一个字节
计算机非零表示成立，只有0或者指针空表示不成立
一般充当函数返回值，或者开关
正常输出是0和1
C++专有的赋值方式，false和true

	bool bNum = -1;
	cout << bNum << endl;
	bNum = false;
	bNum = true;
	cout << bNum << endl;
	//boolalpha 用true和false方式打印bool类型
	cout << boolalpha << bNum << endl;

2.指针的NULL C++种改为 nullptr

int* p = nullptr;

3.引用类型
		理解为起别名
		基本引用
			类型名& 别名=要起别名的东西;

int a=1;
int& b=a; //a有另一个名字叫b ，a就是b，b就是a
常引用(右值引用)
类型名&& 别名=右值
int&& a=1; //1就是a ，a就是1
4.引用一般用在那些地方

#include <iostream>
using namespace std;
void  testBool() 
{
 bool bNum = 1234;
 cout << bNum << endl;
 bNum = false;
 bNum = true;
 cout << bNum << endl;
 //boolalpha 用true和false方式打印bool类型
 cout << boolalpha << bNum << endl;
}
void testnullptr() 
{
 int* p = nullptr;   //NULL
 char* pc = NULL;
}
void printStr(const char* str) 
{
 cout << str << endl;
}

void testQuote() 
{
 //1.什么是起别名
 int 女朋友 = 1;
 //类型 & 别名=要起别名的东西
 int& 小可爱 = 女朋友;  //小可爱就是女朋友的别名
 小可爱 = 777;
 cout << 女朋友 << endl;
 //2.C++种常量要求更严格
 //想要变量和常量，就必须用const修饰
 printStr("ILoveyou"); //形参必须要有const 
 char str[] = "ILoveyou";
 printStr(str);
 //3.常引用
 //int& x = 1; //直接报错，C++对const要求更严格
 int aa = 1;
 const int& x = 1; //第一种写法:const修饰
 const int& x2 = aa;
 //右值引用,只能给右值起别名
 int&& xx = 1; //常量是右值(运算符的右边)
 //int&& xx2 = aa;   //右值引用只能给右值起别名
}
void modifyA(int a)
{
 a = 1001;
}
void modifyB(int& a)     //int& a=实参;
{
 a = 1001;
}
void swap(int& a, int& b) 
{
 int temp = a;
 a = b;
 b = temp;
}
int g_num = 1001;
void modifyPointA(int* p) 
{
 p = &g_num;
}
void modifyPointB(int*& p)  //int*& p=实参
{
 p = &g_num;
}

//右值引用
void printRightValue(int&& a) 
{
 a += 11;     //可以增加一个可以修改的功能
 cout << a << endl;
}
void printRight(const int& a) 
{
 //a += 11;   //常饮用不能修改
 cout << a << endl;
}
int getData() 
{
 return g_num;
}

int& getValue() 
{
 return g_num;
}


void useQuote() 
{
 int aa = 1;
 modifyA(aa); //拷贝本
 cout << aa << endl;
 modifyB(aa); //任何传参都是赋值的方式传参
 cout << aa << endl;
 int bb = 22;
 swap(aa, bb);
 cout << aa << "\t" << bb << endl;
 int pa = 1008;
 int* p = &pa;
 cout << "当作函数参数" << endl;
 modifyPointA(p);
 cout << *p << endl;
 modifyPointB(p);
 cout << *p << endl;
 printRightValue(11);
 printRight(11);
 //返回值就是一个值，这个值只能是右值
 //getData() = 1001;  错误
 getValue() = 0; //返回引用表示返回变量本身
 cout << g_num << endl;
}




int main() 
{
 //testBool();
 testQuote();
 useQuote();
 return 0;
}

		?函数参数(防止拷贝产生)
		?函数返回值(增加左值使用)
	不能返回局部变量引用
5.自动推断类型auto类型
	必须根据赋值的数据推断类型，不能直接推断

四、函数思想
1.内敛思想 inline关键字
什么样的函数可以成为inline，短小精悍
在结构体中或者类种实现的函数默认内敛(知道即可)
2.函数重载： C++允许同名不同参数函数存在
参数数目不同
参数类型不同
参数顺序不同（一定建立在不同类型的基础上）
3.函数缺省： C++中允许给函数形参初始化
缺省顺序 必须从右往左缺省，缺省的参数中间不能存在没有缺省的
没有参入参数，使用的是默认值

#include <iostream>
using namespace std;
inline int  Max(int a, int b) 
{
 return a > b ? a : b;
}
void print(int a) 
{
 cout << a << endl;
}
void print(int a, int b) 
{
 cout << a + b << endl;
}
//和上面不是顺序不同
//void print(int b, int a) 
//{
// cout << a + b << endl;
//}
void print(int a, char b) 
{
 cout << "int,char" << endl;
 cout << a + b << endl;
}
void print(char a, int b)
{
 cout << a + b << endl;
}
//函数缺省
void printData(int a=1, int b=2, int c=3, int d=4) 
{
 cout << a + b + c + d << endl;
}
int main() 
{
 print(1, 'A'); //重载调用，优先调用类型一致
 //老师的理解: 缺省其实是重载的一种综合写法
 printData();   //a=1 b=2 c=3 d=4
 printData(10);   //a=10 b=2 c=3 d=4
 printData(10, 20);   //a=10 b=20 c=3 d=4
 printData(10, 20, 30);   //a=10 b=20 c=30 d=4 
 printData(10, 20, 30, 40);//a=10 b=20 c=3 d=40
 return 0;
}