C++入门（一）

目录

一.命名空间

二.基本输入输出

三.缺省参数（默认参数）

---

一.命名空间

在定义变量，函数，类的名称时，为了避免命名冲突或名字污染，C++中引入namespace关键字来解决上述问题。

1.namespace定义

namespace后接空间名字和大括号，最后无分号。

namespace name
{
    //定义变量，函数，类
}

2.namespace使用

（1）命名空间中可以定义变量，函数，类型等。（namespace只能定义在全局中）

#include<stdio.h>
namespace space
{
	//变量：
	int a = 1;
	//函数：
	int Add(int x, int y)
	{
		return x + y;
	}
	//结构体：
	struct Node
	{
		struct Node* next;
		int val;
	};
}
int main()
{
	//使用变量：
	printf("%d\n", space::a);
	//使用函数
	int ret = space::Add(1, 1);
	printf("%d\n", ret);
	//使用结构体
	struct space::Node p;//注意space::是在struct类型后面
	return 0;
}

（2）同一个域中不能定义同名变量，不同域中可以定义同名变量。

（3）C++域中有局部域，全局域，命名空间域，类域。

其中局部域和全局域会影响生命周期，但命名空间域和类域不会影响生命周期。

eg1.若只有局部域和全局域，优先查找局部域。若想先查找全局域/命名空间域，可以使用::符号（域作用限定符）

#include<stdio.h>
namespace space1
{
	int a = 2;
}
int a = 0;
int main()
{
	int a = 1;
	printf("%d\n", a);//查找局部域
	printf("%d\n", ::a);//查找全局域
	printf("%d\n", space1::a);//查找命名空间域
	return 0;
}

（4）namespace可以嵌套定义

#include<stdio.h>
namespace space
{
	namespace people1
	{
		int a = 1;
	}
	namespace people2
	{
		int a = 2;
	}
}
int main()
{
	//访问people1：
	printf("%d\n", space::people1::a);
    //访问people2:
	printf("%d\n", space::people2::a);
}

（5）多文件中可以定义同名namespace，系统将默认将他们合并到一起，相当于同一个namepace。

下面以栈的实现为例子：

//第一个文件stack.h:

#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
#include<stdbool.h>

namespace stack//第一次出现namespace stack！！！
{
    // 支持动态增长的栈
    typedef int STDataType;
    typedef struct Stack
    {
	    STDataType* a;
	    int top;		// 栈顶
	    int capacity;  // 容量 
    }ST;//重定义结构体变量


    //栈的具体实现函数：

    // 初始化栈 
    void StackInit(ST* ps);
    // 销毁栈 
    void StackDestroy(ST* ps);
 

    // 入栈 
    void StackPush(ST* ps, STDataType data);
    // 出栈 
    void StackPop(ST* ps);


    // 获取栈顶元素 
    STDataType StackTop(ST* ps);
    // 获取栈中有效元素个数 
    int StackSize(ST* ps);


    // 检测栈是否为空
    bool StackEmpty(ST* ps);
}

//第二个文件stack.c:

#include"stack.h"
namespace stack//第二次出现namespace stack！！！
{
    // 初始化栈 
    void StackInit(ST* ps)
    {
	    assert(ps);//指针不为空

	    ps->a = NULL;//
	    ps->capacity = ps->top = 0;//top==0时，栈里有0个元素
    }

    // 销毁栈 
    void StackDestroy(ST* ps)
    {
	    assert(ps);
	

	    free(ps->a);//释放空间
	    ps->a = NULL;//置为空，防止成为野指针
	    ps->capacity = ps->top = 0;
    }

    // 入栈 
    void StackPush(ST* ps, STDataType data)
    {
	    assert(ps);

	    if (ps->top == ps->capacity)//判断元素个数与数组中的最大容量是否相等，
        //若相等，执行扩容操作
	    {
		int newCapacity = ps->capacity == 0 ? 4 : 2*(ps->capacity);//capacity空间为0，
        //则初始化为4；若有空间，则扩容到原来2倍
		//定义新指针来接收realloc返回值
		STDataType* tmp = (STDataType*)realloc(ps->a, newCapacity * sizeof(STDataType));                         
		if (tmp == NULL)//判断是否扩容失败；
			//若失败，则打印错误信息，并返回
		{
			perror("realloc");
			return;
		}
		//若扩容成功，则改变ps->a地址和ps->capacity大小
		ps->a = tmp;
		ps->capacity = newCapacity;
	    }
	    //入栈：
	    ps->a[ps->top] = data;
	    ps->top++;//别漏！
    }

    // 出栈 
    void StackPop(ST* ps)
    {
	    assert(ps);
	    assert(ps->top > 0);

	    ps->top--;
    }

    // 获取栈顶元素
    STDataType StackTop(ST* ps)
    {
	    assert(ps);
	    assert(ps->top > 0);

	    return ps->a[ps->top - 1];//返回栈顶元素
	    //注意数组下标要-1
    }

    // 获取栈中有效元素个数 
    int StackSize(ST* ps)
    {
	    assert(ps);

	    return ps->top;
    }

    // 检测栈是否为空 
    bool StackEmpty(ST* ps)
    {
	    assert(ps);

	    return ps->top == 0;//该等式成立，即为空，则返回真
    }
}

（6）C++标准库都放在std的命名空间中。

（7）可以使用using展开命名空间的指定成员或者全部成员。（展开后就可以不再用域作用限定符）（在日常练习中可以展开，在项目中不推荐）

#include<stdio.h>
namespace yzc
{
	int a = 1;
	int b = 2;
}

using yzc::b;
int main()
{
	//第一种：使用域作用限定符
	printf("%d\n", yzc::a);
	//第二种：使用using展开命名空间的指定成员
    //适用于项目中经常访问但不冲突的成员
	b = 100;
	printf("%d\n", b);
	return 0;
}

#include<stdio.h>
namespace yzc
{
	int a = 1;
	int b = 2;
}

//第三种：使用using展开命名空间的全部成员
using namespace yzc;
int main()
{
	printf("%d\n", a);
	printf("%d\n", b);
	return 0;
}

二.基本输入输出

1.**<iostream>**定义了标准的输入，输出对象的功能，如cin，cout，endl。

vs编译器中，<iostream>包含了printf与scanf，其他编译器可能需要添加<stdio.h>头文件。

因此可以通过printf与scanf设置精度

2.std命名空间中包含了cin，cout ，endl对象。

std::cin是istream类的对象，面向窄字符的标准输入流

std::cout是ostream类的对象，面向窄字符的标准输出流

std::endl是一个函数，相当于插入一个换行符+刷新缓冲区

3.<< 是流插入运算符，>>是流提取运算符。

4.C++输入输出可以自动识别变量类型，不用指定格式 ，同时还可以支持自定义类型对象的输入输出。

//输出：
//使用using展开命名空间全部成员
#include<iostream>
using namespace std;

int main()
{
	int a = 0;
	char b = 'm';
	float c = 9.1;
	cout << a <<' ' << b <<' '<< c <<' '<< endl;//endl
	cout << a << ' ' << b << ' ' << c << ' ' << '\n';//'\n'
	cout << a << ' ' << b << ' ' << c << ' ' << "\n";//"\n"
	return 0;
}

//输出：
//使用域作用限定符访问成员
#include<iostream>
int main()
{
	int a = 0;
	char b = 'm';
	float c = 9.1;
	std::cout << a << ' ' << b << ' ' << c << ' ' << std::endl;//endl
	std::cout << a << ' ' << b << ' ' << c << ' ' << '\n';//'\n'
	std::cout << a << ' ' << b << ' ' << c << ' ' << "\n";//"\n"
	return 0;
}

//输入+输出：
#include<iostream>
using namespace std;

int main()
{
	int a;
	char b;
	float c;
	cin >> a >> b >> c;
	cout << a <<' '<< b <<' '<< c << endl;
	return 0;
}

注：

//加入以下代码可以提高输入输出效率，比如在竞赛题中
//或者交替使用C语言中的printf和scanf
#include<iostream>
using namespace std;
int main()
{
	ios_base::sync_with_stdio(false);
	cin.tie(nullptr);
	cout.tie(nullptr);
	return 0;
}

三.缺省参数（默认参数）

1.声明或定义函数时给函数参数与一个缺省值。即在调用时，若没有指定实参大小则采用形参的缺省值。

2.缺省参数分为全缺省和半缺省。

全缺省即全部形参都有缺省值，半缺省即部分形参有缺省值。

3.半缺省规定形参从右往左给缺省值且不能跳跃给缺省值。

实参必须从左往右给值，且实参对应形参若无缺省值则必须给实参赋予值。

4.函数声明和定义分离时，缺省参数只能在函数声明中出现。

#include<iostream>
using namespace std;

void add(int x = 1, int y = 2)
{
	cout<<x+y<<endl;
}
int main()
{
	add();//1 + 2 = 3
	add(2);//2 + 2 = 4
	add(3, 3);//3 + 3 = 6
	return 0;
}