C++入门：关键字、命名空间、C++输入输出和缺省参数

Crazy_Rabbits239

已于 2024-03-04 15:24:17 修改

阅读量1k

点赞数 31

分类专栏： C/C++ 文章标签： c++ 开发语言

于 2024-02-27 16:54:48 首次发布

本文链接：https://blog.csdn.net/Crazy_Rabbits/article/details/136319327

版权

C/C++ 专栏收录该内容

18 篇文章 0 订阅

订阅专栏

从本章开始进入C++的学习，C语言指针与结构体部分的内容会在之后择日发布。

一、C++关键字

C++是从C语言上发展而来的语言，在关键字上对C的关键字（32个）进行了保留，同时也扩充了一些新的关键字（31个）。

C++关键字
asm	do	if	return	try	continue
auto	double	inline	short	typedef	for
bool	dynamic_cast	int	signed	typeid	public
case	enum	mutable	static	union	wchar_t
break	else	long	sizeof	typename	throw
catch	explicit	namespace	static_cast	unsigned	default
char	export	new	struct	using	friend
class	extern	operator	switch	virtual	register
const	false	private	template	void	true
const_cast	float	protected	this	volatile	while
delete	goto	reinterpret_cast

二、命名空间

在C语言中，如果在main函数之外定义某些全局变量可能会编译失败，如rand函数:

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<stdlib.h>
int rand = 10;
int main()
{
	printf("%d", rand);
	return 0;
}

可以看到，编译器报了一个错误，在C语言中是这样，那在C++中呢？

#define _CRT_SECURE_NO_WARNINGS
#include<stdlib.h>
#include<iostream>
using namespace std;
int rand = 10;
int main()
{
	printf("%d", rand);
	return 0;
}

在C++也报错了，这是因为在std的作用范围内包含了适用于全局的rand()函数，当你在定义一个全局变量rand时会与原来std的空间的函数冲突。可是你在进行一些项目的时候又不得不用到该函数，有什么解决方法呢？

在上面C++的代码中有这么一条：

using namespace std;

namespace是命名空间，在刚刚的C++代码中由于我展开了std的这个命名空间（可以理解为包含了stdio.h），导致出现了同C语言一样的问题。解决方法如下：

#define _CRT_SECURE_NO_WARNINGS
#include<stdlib.h>
#include<iostream>
using namespace std;
namespace my_test
{
	int rand = 10;
}
int main()
{
	printf("%d", my_test::rand);
	return 0;
}

然后运行程序，你就能看到在控制台上打印出10来了。

其实，命名空间namespace能解决变量、函数和日后要学习的类的名称冲突。使用命名空间的目的是对标识符本地化，以避免命名冲突和名字污染。

1.定义命名空间

定义命名空间需要使用namespace关键字，然后打一个空格接命名空间的名称，再接一对花括号{}，最后在花扩号里面填写命名空间的成员。

//这是一个创建命名空间的实例代码
namespace my_namespace
{
    int x = 10;
    struct Student
    {
        char name[20];
        int age;
    };
    void showMessage(Student* a)
    {
        printf("%s %d", a->name, a->age);
    }
}

命名空间是允许嵌套的：

namespace my_namespace
{
    int x = 10;
    struct Student
    {
        char name[20];
        int age;
    };
    void showMessage(Student* a)
    {
        printf("%s %d\n", a->name, a->age);
    }
    namespace my_inner_namespace
    {
        void Print()
        {
            printf("You have found the inner namespace.\n");
        }
    }
}

一个项目内是可以定义同名的命名空间的，编译器在编译的阶段会将同名的命名空间合并(如果位置在头文件，你需要将头文件引入)，但是并不建议在同名的命名空间中定义同名的变量，这会导致重定义的情况发生。例如：当你在.h中定义了一个namespace，并在其中定义了一个变量x，又在.cpp中一个同名的namespace中定义了一个同名的x，编译器会报错。

//.h
namespace my_namespace
{
	int x = 3;
}
//.cpp
namespace my_namespace
{
	int x = 5;
}

2.使用命名空间

使用命名空间有三种方式，如下：

（1）完全展开：使用using关键字，直接对命名空间进行展开，对命名空间的完全展开是作用于全局的。

#include<iostream>
using namespace std;
namespace my_namespace
{
    int x = 10;
    struct Student
    {
        char name[20];
        int age;
    };
    void showMessage(Student* a)
    {
        printf("%s %d\n", a->name, a->age);
    }
    namespace my_inner_namespace
    {
        void Print()
        {
            printf("You have found the inner namespace.\n");
        }
    }
}
using namespace my_namespace;
int main()
{
    Student a = { "xiaoming",18 };
    printf("%d\n", x);
    showMessage(&a);
    return 0;
}

（2）部分展开：使用using关键字，仅针对部分你需要的内容进行展开，该部分内容对全局是适用的。

#include<iostream>
using namespace std;
namespace my_namespace
{
    int x = 10;
    struct Student
    {
        char name[20];
        int age;
    };
    void showMessage(Student* a)
    {
        printf("%s %d\n", a->name, a->age);
    }
    namespace my_inner_namespace
    {
        void Print()
        {
            printf("You have found the inner namespace.\n");
        }
    }
}
//仅需要展开某个成员供全局使用时，使用::作用域操作符，此时不需要再写namespace，直接是using+名称+::+成员名
using my_namespace::Student;
using my_namespace::showMessage;
//注意：当展开命名空间里面的函数时，不需要添加括号，否则编译会不给通过
int main()
{
    Student a = { "xiaoming",18 };
    showMessage(&a);
    return 0;
}

（3）适时展开：当你需要使用某个命名空间里面的成员的时候，你可以选择只展开他，但是这会造成该变量在全局都是适用的，可能导致与其他的命名空间的冲突。此时，我们会采用一个新的运算符::域限制运算符（作用域操作符）来限制某个成员的使用，如下例：

#include<stdlib.h>
#include<iostream>
using namespace std;
namespace my_namespace
{
    int x = 10;
    struct Student
    {
        char name[20];
        int age;
    };
    void showMessage(Student* a)
    {
        printf("%s %d\n", a->name, a->age);
    }
    namespace my_inner_namespace
    {
        void Print()
        {
            printf("You have found the inner namespace.\n");
        }
    }
}
int main()
{
    printf("%d",my_namespace::x);
    return 0;
}

注意：当使用内层的命名空间时，无法通过已展开的namespace直接访问，需要通过如下方法访问：

（a）.再次展开命名空间

#include<stdlib.h>
#include<iostream>
using namespace std;
namespace my_namespace
{
    int x = 10;
    struct Student
    {
        char name[20];
        int age;
    };
    void showMessage(Student* a)
    {
        printf("%s %d\n", a->name, a->age);
    }
    namespace my_inner_namespace
    {
        void Print()
        {
            printf("You have found the inner namespace.\n");
        }
    }
}
using namespace my_namespace;
using namespace my_inner_namespace;
int main()
{
    Print();
    return 0;
}

（b）.直接连环::

#include<stdlib.h>
#include<iostream>
using namespace std;
namespace my_namespace
{
    int x = 10;
    struct Student
    {
        char name[20];
        int age;
    };
    void showMessage(Student* a)
    {
        printf("%s %d\n", a->name, a->age);
    }
    namespace my_inner_namespace
    {
        void Print()
        {
            printf("You have found the inner namespace.\n");
        }
    }
}
int main()
{
    my_namespace::my_inner_namespace::Print();
    return 0;
}

（c）.展开外层命名空间后，再使用::（类比(2),不再演示）

三、C++的输入输出

在C语言中，我们通常使用scanf和printf两个函数并借助占位符来进行输入输出，在C++中我们一般使用cout（标准输出对象）和cin（标准输入对象），需要注意的是：

使用cout和cin需要引入头文件<iostream>并展开命名空间std，该头文件不需要加.h。
使用cout和cin不需要占位符来手动控制格式，C++的输入输出可以自动识别变量的类型
<<是流插入运算符，>>是流提取运算符，这一块涉及到运算符重载的知识，此处不作讲解
我们习惯上会在cout结束时添加上一个endl，endl会自动帮我们换行，与'\n'功能一样

下面是一个cout与cin的实例：

#include<iostream>
using namespace std;
int main()
{
	int a = 2;
	//打印a
	cout << a << endl;
	//修改a
	cin >> a;
	//打印a
	cout << a << endl;
	return 0;
}

当然，与C语言一样，C++允许多重输入输出：

#include<iostream>
using namespace std;
int main()
{
	int a;
	char b;
	char c[20];
	cin >> a >> b >> c;
	cout << a << b << c << endl;
	cout << a << " " << b << endl << c << endl;
	return 0;
}

后续补充：当输出一个浮点数时，如果这个数字小数点后是一堆0，打印时会忽略掉，以整型的形式打印。如果想要保留浮点数的小数位，推荐使用C语言的printf进行打印，便于控制精度