[C++知识库]Day1 :C与C++的区别

目录

头文件与命名空间

?基本输入和输出

?新数据类型

函数思想

头文件与命名空间

C语言中的: 采用原来方式包含可以，可以用C++包含方式，去掉.h 加个c

#include<cstdio>

namespace:

①存在的意义：增加标识符的使用率（小郭的age和小杰的age）

namespace guo//基本写法 namespace+空间名
{
    int age=17;
}
name space jie
{
    int age=18;
}

②访问：作用域分辨符：：（空间名和类名的限定+标识全局变量）

void test()
{
	printf("%d\n", jie::age);
	printf("%d\n", guo::age);
}

输出：

18?

17

?③using语法（为了省事）：注意仅在作用域中using后面的语句生效

void test()
{
	using namespace jie;
	printf("%d\n", age);
	printf("%d\n", guo::age);
}

为了避免二义性的问题，尽量别在用using namespace guo;

因为以下都是生效区域，编译器不知道该用jie还是guo的age。

?④空间名的嵌套与空间内容访问

namespace guozijie
{
	double BMI = 1.8;
	namespace special
	{
		int height = 185;
		int weight = 70;
	}
}

嵌套定义格式如上

void test()
{
	printf("%f\n", guozijie::BMI);
	printf("%d\n", guozijie::special::height);
	printf("%d\n", guozijie::special::weight);
	using namespace guozijie;
	printf("%f\n", BMI);
	printf("%d\n", special::height);
	printf("%d\n", special::weight);
	using namespace special;
	printf("%f\n", BMI);
	printf("%d\n", height);
	printf("%d\n", weight);
}

很好理解：剥洋葱~~~~~~链式法则

?基本输入和输出

（恭喜你解锁新技能）

头文件

#include<iostream>//用的是std这个空间
using namespace std;

?cout<<输出? ? ?cin>>输入 （c语言中的格式格式控制符同样支持）

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

void test3()
{
	cout << "examing week.i'm so busy.\n";
	char str[] = "examing week.i'm so busy.\n";
	cout << str;
	cout << 1.1;
	cout << "\n";
}

②一次性打印多个数据

void test3()
{
	int a = 111;
	float k = 12.1;
	cout << a << "\t" << int(k) << "\n";
}

?这里注意

强制类型转换 C++可以这样写 int（k）

隐士类型和c基本一样

③C++换行 ?endl替换\n的作用

cout<<"C++" << endl;

?当不加

using namespace ?std;

std::cout << "没有写using namespace std" << std::endl;

④一次处理多个

?ps：输入问题

空格键入问题：

	char str[10] = { 0 };
	cin >> str;
	cout << str;//这种写法只能是中间没有空格（'\0'）的输入方式才行

上面是输入，下面是输出。

解决： cin.getline(str,10);

? ? ? ? ? ? cout.write(str,10);

	char str[10] = { 0 };
	cin.getline(str, 10);//类似gets_s(str, 10);
	cout.write(str, 10);

?输入：abcd? dbca

输出： abcd? dbca

void test3()
{
	char str[10];
	cin >> str;
	cout << str;
	char ch;
	cin >> ch;
	cout << ch;
}

?输入：A Pig

?输出：AP

原因分析:首先C++里面数据之间是一个空格为分隔的，先是输入str遇到空格停止输入，此时缓冲区内还含有空格+Pig，读入ch时跳过空格，读进去一个P。

解决：

方法一：

srtbuf(stdin,NULL);

方法二：

这样写是错误的！！！

while(getchar()!="\n");×

会导致“c++操作数类型不兼容 ("char"和 "const char*")”的问题

解决：双引号是 C++ 中 c 字符串的快捷语法。如果要比较单个字符，则必须改用单引号。您可以简单地将代码更改为:

	while (getchar() != '\n') ;

以供引用:（原因）

• "x"?=?const char *
• 'x'?=?char

?新数据类型

①bool类型：一个字节+非零表示成立，只有0或者指针空表示不成立+

C++专有的赋值方式，false和true

如何以字母形式输出？又怎么取消？

Ans：当使用boolalpha后，以后的bool类型结果都将以（持续的状态）true或false形式输出，除非使用noboolalpha取消?boolalpha流的格式标志。

void  testBool()
{
	bool bNum = 1234;   bool anum = 0;
	cout << bNum << endl;//1
	//boolalpha 用true和false方式打印bool类型
	cout << boolalpha << bNum << endl;//true
	cout << anum << endl;//false
	//noboolalpha取消状态
	cout << noboolalpha << bNum << "\t" << anum << endl;
}

②指针的NULL 在C++中改为 nullptr

int*p=nullptr；//NULL

?③引用类型：理解为起别名（最好

1.第一类引用：基本引用

类型名& 别名=要起别名的东西;

void testquote()
{
	int b = 1;
	int& c = b;//b的另一个名字就是c  c就是b  b就是c
}

?2.第二类引用：常引用

类型名&& 别名=右值；[常量是右值(运算符的右边)]

只能给右值取别名

int&& age=18;//顾名思义，给一个常量取别名的方法

18是年龄 ，年龄就是18.?

ps：C++种常量要求更严格

int& a=1；

直接报错！！ ！想要变量和常量，就必须用const修饰

void printStr(const char* str) 
{
	cout << str << endl;
}

printStr("ILoveyou"); //形参必须要有const

形参必须要有const

除了常引用外（int&& a=1；）外，还可以这样写：

const int& a=1;

?引用的作用：

①函数参数(防止拷贝产生)? ?int& a=实参

void modify_one(int a)
{
	a = 666;
}
void modify_two(int& a)     //int& a=实参;
{
	a = 666;
}
void swap(int& a, int& b)
{
	int temp = a;
	a = b;
	b = temp;
}
int main()
{
	int a = 1;
	modify_one(a);
	cout <<"修改前"<<a << endl;
	modify_two(a);
	cout << "修改后" << a << endl;
	return 0;
}

同理我们swap两个值的时候也可以用引用类型?void swap(int& a,int& b);

int m = 10;
void modifyPoint(int*& a)
{
	a = &m;
}
int main()
{
	int b = 1;
	int* k = &b;
	cout << "修改前k的地址" << k << endl;
	modifyPoint(k);
	cout << "修改后k的地址" << k << endl;
	return 0;
}

这是修改地址。?

②函数返回值(增加左值使用)（不能返回局部变量引用）

int num = 100;
int getData()
{
	return num;
}
int& getValue()
{
	return num;
}
int main()
{
	//getDate()=0;左值无法修改！！这样写会报错
	getValue()=	0;		//返回引用表示返回变量本身
	cout <<num<< endl;
	return 0;
}

?③自动推断类型auto类型： 必须根据赋值的数据推断类型，不能直接推断

函数思想

①内敛思想 inline关键字

（内联是以代码膨胀复制为代价，仅仅省去了函数调用的开销，从而提高函数的执行效率）

是一种“用于实现”的关键字，而不是一种“用于声明”的关键字。

• 什么样的函数可以成为inline，短小精悍

• 在结构体中或者类种实现的函数默认内敛

• inline int sum(int a, int b, int c)
  {
  	return (a + b + c);
  }

?②函数重载：?C++允许同名不同参数函数存在

• 参数数目不同

• 参数类型不同

• 参数顺序不同（一定建立在不同类型的基础上）

• void print(int a)
  {
  }
  void print(int a, char ch)
  {
  }
  void print(char ch,int a)
  {
  }
  int main()
  {
  print(1657,'a');//重载调用，优先调用类型一致
  return 0;
  }

?重载调用，优先调用类型一致

③函数缺省： C++中允许给函数形参初始化

+ 缺省顺序 必须从右往左缺省，缺省的参数中间不能存在没有缺省的
+ 没有参入参数，使用的是默认值

void printData(int a=1, int b=2, int c=3, int d=4) 
{
	cout << a + b + c + d << endl;
}
int main() 
{
	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;
}