Day_01 C与C++区别

最新推荐文章于 2024-07-14 14:55:20 发布

只吃小猫的咸鱼

最新推荐文章于 2024-07-14 14:55:20 发布

阅读量428

点赞数 2

文章标签： c语言 c++ 开发语言

本文链接：https://blog.csdn.net/qq_29941503/article/details/121297524

版权

大纲

1.C++头文件和命名空间

2.C++输入输出流

3.C++新增数据类型

4.C++函数思想

具体内容：

1.C++头文件和命名空间

c++标准输入输出流通过的是#include<iostream>头文件

C++的头文件是向下兼容C的在C++中也可以用#include<stdio.h>

除此以外C++中调用C的头文件还可以通去掉.h加前缀c来引用

例如 #include<cstdio> (#include<stdio.h>)

说完C++头文件来说说命名空间。命名空间是C++里面独有的特性

由于命名空间的引入可以提高标识符的使用率

//示例
//命名一个命名空间为A的命名空间
namescape A{
    int a=1;
    int b=1
}
//命名一个命名空间为B的命名空间
namescape B{
    int a=1;
    int b=1
}

不同的命名空间里的变量名可以是相同的 ，互不影响，且命名空间中定义的变量全部都是全局变量，命名空间中定义的变量叫做空间中的成员，命名空间中也可以定义或者申明函数。

#include<iostream>
using namespace std;
namespace A{
    void print();    //申明函数
    void print1(){
        printf("这是一个命名空间A中的函数");
    }    
}

int main(){

    A::print1();


    reutrn 0;
}

如上述代码所示，在命名空间A中定义一个函数 print1() 和申明一个函数 print()，（申明的函数如有需要，可以在命名空间外来定义）。

在命名空间定义的变量和函数我们该如何调用呢？可以通过 作用域分辨符：： 来引用它们。

说到这里让我们先来了解一下作用分辨符的具体作用：1.作用分辨符可以用来空间名限定，类名限定。 2.作用分辨符可以用来标识全局变量。

下面就是标识全局变量的用法作用分辨符+全局变量名

#include <iostream>
using namespace std;
int a=1;
int main(){
    int a=11;
    cout<<a<<endl;        //这里的a是局部变量（根据就近原则） a=11
    cout<<::a<<endl;      //这里的通过作用域分辨符来标识全局变量 a=1
    return 0;
}

如何通过作用域分辨符来引用命名空间中的变量呢？

#include<iostream>
using namespace std;

namespace A{
    int a=1;
    void print();
]

//在命名空间中申明函数 ，在命名空间外定义函数
//需要注意的是 C++不能在main函数中定义函数（即不能嵌套定义）  而c可以在main中定义函数  

void A::print(){
    cout<<"Hellow!"<<endl;
}

int main(){
    cout<<A::a<<endl;
    return 0;
}

命名空间的嵌套：在命名空间中嵌套命名空间只需要通过作用域分辨符一层一层的引用就行

#include<iostream>
using namespace std;
namespace A{
    int aa=1;
    namespace B{
       int bb=2;
    }
}

int main(){
    
    cout<<A::aa<<endl;
    cout<<A::B::bb<<endl;

    return 0;
}

由于每次都要使用命名空间+作用域标识符来引用命名空间的变量稍显的复杂，

这时using语法的作用就体现出来了 using namespace 命名空间名;

using语句的作用域是在它的下方。使用using语句后就可以直接使用命名空间中的变量。

例如上述代码中定义

using namespace A;

cout<<aa<<endl; //就可以直接输出aa的值

cout<<B::bb<<endl; //对于嵌套也是可以省略A的命名空间

using namespace A::B; //对嵌套的命名空间定义using

cout << bb<<endll

注意：using 语法定义的时候要避免二义性的出现，如下图 A ,B中都有a这个变量，且对AB都using定义时再去直接使用变量a 编译器会不知道去选择哪个a而报错

namespace A{
     int a=1;       

}

namespace B{
     int a=2;
}
using namespace A;
using namespace B;

using namespace std;

C++程序开头一般情况都会包含命名空间 using namespace std;

std是标准库的命名空间，不加std的话，要是程序用到标准库里的东西需要加上 std::前缀

例如 std::cout std::cin

2.C++输入输出

cout<< 输出 cin>>输入 C++中默认把回车换行符或者空格当作输入的间隔符

我们来看下面这段代码如果我们输入”i Love you“ 程序运行的结果将会输出 i 和 L 并且不需要二次输入.

#include <iostream>
int main(){

    char str[10]
    cin >> str;
    cout << str;
    char c = 0;
    cin >> c;
    cout << c;
    return 0;
}

因为第一次输入读取了 "i" 之后遇到空格程序就认为第一次输入结束，而第二次输入，程序接着从缓冲区中读取数据自动跳过空格读取到 “L” 。

这就是缓冲区残留所造成的影响。要避免这种情况也很容易，在接受下一个字符时清空缓冲区就行了可以加 while( getchar() != "\n"); 来清空缓冲区或者 fflush( stdin ) setbuf( stdin, NULL)两种库函数来清空缓冲区。

注：若要输入带空格的字符串也可以通过 cin.getline(str,10) 来输入对应通过cout.write(str,10)来输出。

3.C++新增数据类型

(1).bool类型：

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

(可以通过 cout<<boolalpha<<boolNum 的方式已true或false的方式来打印boolNum)

(2).指针类型:

C++中空指针不再指向NULL 而是指向 nullptr

(3).引用类型

理解为起别名
基本引用

//类型名& 别名 = 需要起别名的变量
int a=1;
int& aa=a;    //aa就是a 相当于给a起了个别名

可以将类型名& 看作一个新的类型如 int& 可以看作 int& 类型

常引用、右值引用

第一种写法---右值引用

//类型名&& 别名=右值
int&& a=1;   //1就是a ，a就是1

第二种写法--常引用

//通过const修饰 来引用常量
const int& a=1;

引用一般用在哪些地方？

1. 函数参数(防止拷贝产生)

#include <iostream>
using namespace std;
void test(int& aa){      //参数传递是值传递 所以 int& aa=a;
    aa=11;               //这里的aa就相当于实参a ,改变aa的值,a也会改变
    cout <<a<<endl;
}

int main(){
    int a=1;
    test(a);        //可以不通过指针就改变实参a的值
    return 0;
}

值得注意的是，当引用类型作为函数的形参时要关注常引用和右值引用的区别如下

#include <iostream>
using namespace std;

//常引用
void test1(const int& a){
    a+=11;                //无法修改a的值  这样写直接报错
    cout << a << endl;
}

//右值引用
void test2(int&& a){
    a+=11;            //可以修改a的值，但不是真的修改常量区a的值 相当于复制了a的值到栈区再修改
    cout << a << endl;
}

int main(){
    test1(11);
    test2(11);
    return 0;
}

常引用作为函数参数时可以传递常量但不能修改常量的值

而右值引用作为函数参数时可以传递常量也能够修改值，但修改的并不是常量区的值，可以理解为从常量区拷贝了一份相同的到栈区，然后做值的操作。

2. 函数返回值(增加右值使用)

引用类型也可以作为函数的返回值

#include <iostream>
using namespace std;
int num=10;

//基本变量作为返回值
int test1(){    
    return num;
}

//引用变量作为返回值
int& test2(){
   return num;
}

int main(){
    

    test1()=100;   //不行 返回的是个值 即右值 不能再被赋值
    test2()=100;   //可以 引用类型的返回值相 当于引用类型本身 即 test2() 相当于num的引用类型
    return 0;
}

要注意引用类型返回值的性质这里的 int& 返回值是个左值可以被二次修改

而 int 的返回值不能被二次修改他就是个常量。

特别注意：函数返回值(增加右值使用) --不能返回函数中局部变量的引用类似于C中不能返回函数中局部变量的地址。

Auto --- 自动识别变量类型

C++中的auto和C中的auto不一样，C++中淘汰了C语言用法，只有自动推断用法。根据变量被赋值的类型来推断变量的类型。

注意：auto不能直接定义变量必须要初始化变量时才能用没有赋值的变量就没办法推断类型

4.C++函数思想

内敛思想 inline关键字
- 什么样的函数可以成为inline，短小精悍
- 在结构体中或者类种实现的函数默认内敛(知道即可)
函数重载： C++允许同名不同参数函数存在
- 参数数目不同
- 参数类型不同
- 参数顺序不同（一定建立在不同类型的基础上）

函数缺省： 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;
}

只吃小猫的咸鱼

关注

2
点赞
踩
1

收藏

觉得还不错? 一键收藏
1
评论
Day_01 C与C++区别

大纲1.C++头文件和命名空间2.C++输入输出流3.C++新增数据类型4.C++函数思想具体内容：1.C++头文件和命名空间c++标准输入输出流通过的是#include<iostream>头文件C++的头文件是向下兼容C的在C++中也可以用#include<stdio.h>除此以外C++中调用C的头文件还可以通去掉.h加前缀c来引用例如 #include<cstdio> (#include<stdio.h&gt..
复制链接

扫一扫