【C++】语法、输入&&输出、命名空间、结构体增强、bool

古城微笑少年丶 2023-09-28 09:13 23阅读 0赞

(doge)欸嘿！

记录一下，激动人心的时刻——进入C++的学习阶段

浅谈原因吧~

**兴趣兴趣兴趣~**

*博主目前其实已经是正在学第三遍C语言了，转专业前自学一遍，现在跟着学校学一遍，自己下来整理加自学一遍，呜~越学越感觉真的好有趣，按何不住对知识的渴望，所以开始C++的更新啦！*

*以后的时间里博主会将C与C++同时更新，尽情期待吧！*

*鲁老爷子，我想知道是不是我变秃了也就变强了？*

*![39aa08ac78024af8acdb3febcd3f98f7.jpeg][]*

--------------------

**目录**

C++基础语法

语法框架

输入 && 输出

C++对C的扩展

::作用域运算符

命名空间namespace

1.创建命名空间

2.嵌套命名

3.命名空间的开放特性

5.声明和实现可分离

6.无命名空间

7.命名空间取别名

8.使用using声明 成员或整个空间

结构体增强 && bool

--------------------

# C++基础语法 #

## 语法框架 ##

咱可以类比一下C的框架

//C语言
    #include<stdio.h>
    int main()
    {
    
    	return 0;
    }

//C++
    #include<iostream>
    
    using namespace std;
    //命名空间，目前框架可以有，也可以没有，后面会细讲
    
    int main()
    {
    	return 0;
    }

相差不大，头文件变成了iostream ，都是以main函数为入口，到return 0;结束

> \#include<iostream>
> 
> 包含的文件是标准输入输出流（i是input的缩写，o是output的缩写，stream表示流）。

*其实只是用iostream文件当一个例子，我们都知道，再C语言中，我们的输入输出来源于stdio.h，函数有很多，最常用的是printf和scanf，而C++中特有的iostream文件就不同了，往下看~*

##  ##

## 输入 && 输出 ##

**输入：**

看代码及注释，一目了然

#include<iostream>//标准输入输出流函数
    
    //使用命名空间std
    
    using namespace std;
    //没有这句话，输出前后都要加std:: 当要写很多输入输出时，无疑是很麻烦的
    
    int main()
    {
    	//cout输出设备
    	//""表示字符串类型
    	//<<表示流向
    	//endl表示换行
    	cout << "hello C++" << endl;
    	//根据流向,过程是先输出hello C++ 再输出endl
    	return 0;
    }

如果没有using namespace std;命名的空间std,需要这样去写:

#include<iostream>
    
    int main()
    {
    	std::cout << "hello C++" << std::endl;
        //必须使用域作用符“::”，否则会报错
    	return 0;
    }

**输入：**

void Print_1()
    {
    	//cin输入
    	int input = 0;
    	cout << "请输入:>";
    	cin >> input;//cin会根据变量input的类型获取值
    	cout << "input = " << input << endl;
    }
    void Print_2()
    {
    	//多输入
    	int input_1 = 0;
    	int input_2 = 0;
    	cin >> input_1 >> input_2;
    	cout << input_1 << " + " << input_2 << " = " << input_1 + input_2 << endl;
    }

--------------------

# C++对C的扩展 #

> 面向对象编程概述：是一种以对象为中心的编程思想
> 
> 数据结构和算法被看成一个整体，称为对象
> 
> 程序 = 对象 + 对象...
> 
> 面对对象的三大特点
> 
> 封装：**把客观事物封装成抽象的类，并且类可以把自己的数据和方法只让可信的类或者对象操作，对不可信的进行信息隐藏。**
> 
> 继承：**它可以使用现有类的所有功能，并在无需重新编写原来的类的情况下对这些功能进行扩展。**
> 
> 多态：**是面向对象的重要特性，简单说：“一个接口，多种实现”，就是同一种事物表现出的多种形态。**

### ::作用域运算符 ###

类比C语言，看以下代码

#include<iostream>
    
    using namespace std;
    int a = 8;
    int main()
    {
    	int a = 6;
    	cout << "a = " << a << endl;
    	cout << "a = " << ::a << endl;
    	return 0;
    }

实际上C++和C一样，默认打印局部变量，但是如果非要打印同名的全局变量，需要再同名的变量名前加上 :: 就可以去访问全局变量

*所以以上代码的输出结果是*

![4f0a898c3fc242e3b41ed03c98d871b7.png][]

现在只需知道以下即可，以后会细讲~

## 命名空间namespace ##

### 1.创建命名空间 ###

> 通俗的讲，就是如果你写的工程越大，可能就会遇到变量名的冲突，比如，同名，这时，为了避免命名冲突，就给这些变量可以穿上一个“马甲”，给他封装一下，封装的格式我们叫命名空间，被封装的对象可以是符号常量，变量，函数，结构，枚举，类和对象等等。

看看以下代码更易理解

#include<iostream>
    
    using namespace std;
    
    namespace A //这里 A 为命名空间的名字，可以随意取
    {
    	int a = 1;
    }//注意这里不能加分号，不要和结构体弄混
    namespace B
    {
    	int a = 2;
    }
    int main()
    {
    	cout << "a = " << A::a << endl;//这里表示所属关系a属于A
    	cout << "a = " << B::a << endl;//这里表示所属关系a属于B
    	return 0;
    }

*这里要注意，命名空间只能在全局范围内定义，不能在函数内定义 !*

### 2.嵌套命名 ###

*可以嵌套使用，可以类比C语言的函数嵌套，如下代码*

#include<iostream>
    
    using namespace std;
    
    namespace A
    {
    	int a = 2;
    	namespace B
    	{
    		int a = 1;
    	}
    }
    int main()
    {
    	cout << "a = " << A::a << endl;
    	cout << "a = " << A::B::a << endl;//注意这里访问时的归属
    	return 0;
    }

### 3.命名空间的开放特性 ###

怎么去理解**开放特性**呢？

*看如下代码:*

namespace A 
    {
    	int a = 1;
    }
    
    //...  此处省略一万行代码
    
    namespace A
    {
    	void test()
    	{
    		cout << "hello C++" << endl;
    	}
    }

*解释：当你写一个特别大的程序时，忘记自己之前有创建过命名空间A，这时，你继续去创建一个同名的命名空间是允许的，并且往这个新的空间里添加的东西最后会与你创建的所有命名空间A合并到一起。*

### 5.声明和实现可分离 ###

namespace A 
    {
    	void Print();
    }
    void A::Print()
    {
    	cout << "A::" << endl;
    }

*可以观察到，在Print函数前加了作用域A，表示是来源于命名空间的A的函数声明，否则如果没有加上作用域A，可能还会显示来链接错误。*

### 6.无命名空间 ###

*意味着命名空间中创建的表示符只能在本文件中使用，就像在C语言中的static修饰的变量一样，使其只可作为内部连接。*

#include<iostream>
    
    using namespace std;
    
    namespace 
    {
    	int a = 5;
    }
    
    int main()
    {
    	cout << "a = " << a << endl;
    	return 0;
    }

*值得注意的是倘若定义一个全局变量a，运行时编译器就会报错!*

*如下：*

#include<iostream>
    
    using namespace std;
    
    namespace 
    {
    	int a = 5;
    }
    
    int a = 2;
    
    int main()
    {
    	cout << "a = " << a << endl;
    	return 0;
    }

### 7.命名空间取别名 ###

#include<iostream>
    
    using namespace std;
    
    namespace student
    {
    	int a = 5;
    }
    
    int main()
    {
    	namespace stu = student;
    	cout << "a = " << stu::a << endl;
        cout << "a = " << student::a << endl;
    	return 0;
    }

*注意这里的namespace stu = student;不是赋值操作，这时C++的语法一部分，这里是给student这个命名空间重新取了一个名字叫stu，访问的时候可以用stu,也可以用student。*

### 8.使用using声明 成员或整个空间 ###

#include<iostream>
    
    using namespace std;
    
    namespace A
    {
    	int a = 5;
    	int b = 3;
    }
    
    int main()
    {
    	using A::a;
    	//这个声明只对A中的a成员有效，要用b的话，需要再次声明
    	
    	//int a = 1; 小心！
    
    	cout << "a = " << a << endl;//有了声明以后就可省略作用域了
    	return 0;
    }

*这样的声明其实不建议去写，还是推荐通过写作用域的方式来访问，上面代码这种方式有副作用，倘若我继续创建一个局部变量int a = 1;就会与声明下面访问a变量冲突。*

*还有一个副作用：碰到函数重载，如下代码*

#include<iostream>
    
    using namespace std;
    
    namespace A
    {
    	void Fun() {}
    	void Fun(int x) {}
    	void Fun(int x, int y) {}
    }
    
    int main()
    {
    	using A::Fun;
    	//此时编译器并不知道执行哪一个Fun函数
    	return 0;
    }

*编译器:"&%@\#..."*

接下来看看声明整个命名空间

#include<iostream>
    
    using namespace std;
    
    namespace A
    {
        int a = 1;
        int b = 2;
        int c = 3;
    }
    
    int main()
    {
    	using namespace A;
    	return 0;
    }

*遵循的原则是：先从局部变量开始寻找需要访问的变量，若找不到，再去命名空间寻找。*

## 结构体增强 && bool ##

> 1. C语言定义结构体变量需要加上struct关键字，而C++不用。
> 
> 2. C++结构体可以定义成员函数，C语言不可以

#include<iostream>
    
    using namespace std;
    
    struct stu
    {
    	string _name = 0;//string是C++特有的字符串类型（与C比较）
    	int _age = 0;
    	void Name(string name)
    	{
    		_name = name;
    	}
    	void Age(int age)
    	{
    		_age = age;
    	}
    };
    
    int main()
    {
    	stu s;//这里创建结构体变量可以不用加结构体关键字struct
    	s.Name("Jaychou");
    	s.Age(36);
    	return 0;
    }

> bool类型关键字有两种内置的常量true(转换为整数是1)和false(0),占一个字节大小，给bool类型赋值时，非零全部转化为true(1)，零转化为false(0)。

int main()
    {
    	bool judg= 10;//没有什么意义，因为还是会转化成ture(1)。
    	return 0;
    }

*C++对C的扩展内容未完，下章提到 引用、函数重载、函数的默认参数与展位参数。*

**码字不易~**

[39aa08ac78024af8acdb3febcd3f98f7.jpeg]: https://img-blog.csdnimg.cn/39aa08ac78024af8acdb3febcd3f98f7.jpeg
[4f0a898c3fc242e3b41ed03c98d871b7.png]: https://img-blog.csdnimg.cn/4f0a898c3fc242e3b41ed03c98d871b7.png