C++中的cout和endl

在c语言中我们都学习过helloworld程序，那么在c++中如何写一个helloworld呢？

#include<iostream>

//命名空间
using namespace std;

int main(void)
{
    int a;
    //cout 可用于在计算机屏幕上显示信息  
    //endl是回车，换行的意思
    cout << "hello world" << endl;
    cin >> a;
    cout << "a=" << a << endl;
    return 0;
}

#if 0    
#include<stdio.h>

int main()
{
    int a = 0;
    printf("hello world\n");
    scanf("%d". & a);
    return 0;
}
#endif

命名空间(namespace)的使用

所谓namespace，是指标识符的各种可见范围。C++标准程序库中的所有标识符都被定义于一个名为std的namespace中。

由于namespace的概念，使用C++标准程序库的任何标识符时，可以有三种选择：

1）直接指定标识符。例如std::ostream而不是ostream。完整语句如 下：

std::cout	<<	std::hex	<<	3.4	<<	std::endl;

2）使用using关键字。

using	std::cout;	
using	std::endl;	
using	std::cin；

以上程序可以写成 ：

cout	<<	std::hex	<<	3.4	<<	endl;

下面详细介绍了三种定义方法：

#include<iostream>

//iostream 提供了一个叫命名空间的东西，标准的命名空间是std
//方式2：
#if 0
using std::cout;
using std::endl; 
using std::cin;
#endif

//方式3：
using namespace std;

int main(void)
{ 
	int a = 0;
#if 0
	//方式1：
	std::cout << "nihao " << std::endl;
	std::cout << "hello " << std::endl;
#endif
	cout << "nihao " << endl;
	cin >> a;
	return 0;
}

输出结果：nihao

除了使用系统提供的std我们也可以自定义命名空间，自定义命名空间方法如下：

#define _CRT_SECURE_NO_WARNINGS
#include<iostream>

using namespace std;

typedef struct student
{

}student_t;


//定义一个命名空间
namespace spaceA 
{
	int g_a = 10;

}

namespace spaceB
{
	int a = 20;

	namespace spaceC
	{
		struct teacher
		{
			int id;
			char name[64];
		};
	}
	namespace spaceD
	{
		struct teacher
		{
			int id;
			char name[64];
		};
	}
}

int main()
{
	//using spaceA::g_a;
	using namespace spaceA;
	cout << g_a << endl;

	//spaceB::spaceC::teacher t1;
	//using spaceB::spaceC::teacher;
	//teacher t1;

	using namespace spaceB::spaceC;
	spaceB::spaceC::teacher t1;

	t1.id = 10;

	spaceB::spaceD::teacher t2;
	t2.id = 20;

	return 0;
}

输出结果:10

C++语言相比于C语言语法增强的地方

#define _CRT_SECURE_NO_WARNINGS
#include<iostream>

using namespace std;

//C++语言对全局变量的检测能力增强
int g_val;//bss段    这个段的数据都为0
//int g_Val = 20;

struct student
{
	char name[64];
	int id;
};


void test01()
{
	//定义一个变量，可以随用随定义
	int i = 0;

	for (int i = 0; i < 10; i++)
	{

	}

	int b = 10;
	cout << "b" << b << endl;
}


void test02()
{
	struct student s1;
	s1.id = 20;
}

int foo()
{
	return 10;
}

int g(int a)
{
	return 10;
}

//bool类型
void test03()
{
	//true 1   false 0  只能取这两个值
 	bool flag = true;
	
	flag = false;

	flag = true;
	cout << "flag(true)" << flag << endl;

	flag = false;
	cout << "flag(true)" << flag << endl;

	flag = -20;
	cout << "flag(true)" << flag << endl;
	cout << sizeof(flag) << endl;//1字节大小

}

void test04()
{
	int a = 10;
	int b = 20;
	int c = 0;
	c = (a < b) ? a : b;
	cout << c << endl;

	//三目运算符可以做左值
	((a < b) ? a : b) = 50;
	cout << "a=" << a << endl;//50
	cout << "b=" << b << endl;//20
}

//c++中const修饰的常量是真正的常量  不可以修改
void test05()
{
	const int a = 10;

	int* p = (int*)&a;

	*p = 20;//这里改变的是临时开辟的temp变量
	cout << "a=" << a << endl;//10
	cout << "*p=" << *p << endl;//20

	int array[a] = { 0 };//ok这里的a是常量 可以编译通过
}

enum season
{
	SPR=0,SUM,AUT,WIN
};

void test06()
{
	enum season s = SPR;
	if (s==AUT)
	{
	}
}
int main()
{
	//test02();
	//g(10, 20, 30);
	//test03();
	//test04();
	//test05();
	test06();
	return 0;
}

引用的基本用法

变量名实质上是一段连续存储空间的别名，是一个标号(门牌号) 通过变量来申请并命名内存空间， 通过变量的名字可以使用存储空间。

引用的概念：

变量名，本身是一段内存的引用，即别名(alias)，引用可以看作一个已定义变量的别名。 引用的语法：Type& name = var；

#include	<iostream>
using namespace	std;	
int	main(void)	
{	
				int	a	=	10;	//c编译器分配4个字节内存,	a内存空间的别名
				int	&b	=	a;		//b就是a的别名
				a	=	11;	//直接赋值
				{	
								int	*p	=	&a;	
								*p	=	12;	
								cout	<<	a	<<endl;	
				}	
				b		=	14;	
				cout	<<	"a	=	"	<<a	<<	",	b	=	"	<<	b	<<endl;	
				return 0;	
}

在这里直接赋值a可以修改a的值，通过指针也可以间接修改a的值，最后同样可以通过引用b来修改a的值(b=14)。

#define _CRT_SECURE_NO_WARNINGS
#include<iostream>


using namespace std;

/*
1.引用没有定义，是一种关系型声明。声明它和原有某一
变量(实体)的关系。故而类型与原类型保持一致，且不分
配内存。与被引用的变量有相同的地址。
2.声明的时候必须初始化，一经声明，不可变更。
3.可对引用，再次引用。多次
*/

void change_value(int *p)//int p=a;
{
	*p = 30;
}

void change_value2(int& r)//int& r=a;
{
	r = 30;
}

int main()
{
	int a = 10;
	int b = 20;

	int* p = &a;
	*p = 30;

	p = &b;
	*p = 20;

	int& re = a;//re 是 a的引用, int&是引用的数据类型

	re = 50;
	re = b;//  这句话的意思是让a=b   b=20->a=20
	re = 50;
	cout << "a=" << a << endl;
	cout << "b=" << b << endl;//b还是20 

	int& re2 = b;//err,引用一定要初始化
	re2 = a;//这句话是改变re2这名名字  让re2以后叫a  而不是将a的值给re2

	int& re3 = re;
	cout << "a=" << a << endl;
	cout << "re=" << re << endl;
	cout << "re3=" << re3 << endl;


	cout << "------------" << endl;
	cout << "a=" << a << endl;
	change_value(&a);
	cout << "a=" << a << endl;

	a = 100;
	cout << "------------" << endl;
	cout << "a=" << a << endl;
	change_value2(a);
	cout << "a=" << a << endl;

	return 0;
}

引用作为函数参数

普通引用在声明时必须用其它的变量进行初始化，引用作为函数参数声明时不进行初始化。

#include	<iostream>
using namespace	std;	
struct	Teacher	
{	
				char	name[64];	
				int	age	;	
};	
void	printfT(Teacher	*pT)	
{	
				cout<<	pT->age	<<endl;	
}	
//pT是t1的别名	,相当于修改了t1
void	printfT2(Teacher	&pT)	
{	
				pT.age	=	33;	
				cout<<pT.age<<endl;	
}	
//pT和t1的是两个不同的变量
void	printfT3(Teacher	pT)	
{	
				cout<<pT.age<<endl;	
				pT.age	=	45;	//只会修改pT变量	,不会修改t1变量
}	
int	main(void)	
{	
				Teacher	t1;	
				t1.age	=	35;	
				printfT(&t1);	
				printfT2(t1);	//pT是t1的别名
				printf("t1.age:%d \n",	t1.age);	//33
				printfT3(t1)	;//	pT是形参	,t1	copy?份数据 给pT
				printf("t1.age:%d \n",	t1.age);	//33
				return 0;	
}

#define _CRT_SECURE_NO_WARNINGS
#include<iostream>

using namespace std;

struct student
{
	int id;
	char name[64];
};

void swap(int* a, int* b)
{
	int temp;
	temp = *a;
	*a = *b;
	*b = temp;
}

void my_swap2(int& a, int& b)
{
	int temp = a;
	a = b;
	b = temp;
}

void printS(struct student s)
{
	cout << s.id << " " << s.name << endl;
}

void printS1(struct student* sp)
{
	cout << sp->id << " " << sp->name << endl;
}

void printS2(struct student& s)
{
	cout << s.id << " " << s.name << endl;
}

int main()
{
	int a = 10;
	int b = 20;
	my_swap2(a, b);
	cout << "a=" << a << endl;
	cout << "b=" << b << endl;
	
	student s1 = { 10,"AC" };
	printS(s1);
	printS1(&s1);
	printS2(s1);

	return 0;
}

引用的本质

#define _CRT_SECURE_NO_WARNINGS
#include<iostream>

using namespace std;

struct typeA
{
	int& a;
};
struct typeB
{
	int* a;
};
struct student
{
	int id;
	char name[64];
};
void motify(int*const a)
{
	*a = 100;
}

//当我们将引用作为函数参数时，编译器会替我们将实参
//取地址并传给引用 
void motify2(int&a)
{
	a = 100;//对一个引用操作赋值的时候，编译器替我们隐藏*操作
}
//如果我们再研究引用时，我们可以将引用当做一个常指针去看待
//当使用引用编程时，就将引用理解为一个变量的别名即可。

int main()
{
	cout << "sizeof(struct typeA)" << sizeof(struct typeA) << endl;//4
	cout << "sizeof(struct typeB)" << sizeof(struct typeB) << endl;//4
	//引用所占用的大小与指针相同

	int a = 10;
	int& re = a;//常量需要初始化，引用也需要初始化，引用可能是一种常量

	//引用可能是一种常指针
	int* const p = &a;
	motify(&a);
	motify2(a);
	return 0;
}

引用作为函数参数

#define _CRT_SECURE_NO_WARNINGS
#include<iostream>

using namespace std;

char* getmem(int num)
{
	char* p = NULL;
	p = (char*)malloc(num);

	return p;
}
int getmem2(char** pp, int num)
{
	char* p = NULL;
	p = (char*)malloc(num);
	*pp = p;
	return 0;
}
int getA1()
{
	int a = 10;
	return a;
}
int getA2(int*a)
{ 
	*a = 10;
	return 0;
}
//引用作为返回值，不要返回局部变量的引用
int& getA3()
{
	int a = 10;
	return a;
}
int& getA4()
{
	static int a = 10;//该值在全局区存放 不存在风险
	return a;//ok  
}
int main()
{ 
	int a = 0;
	char* pp = NULL;

	a = getA1();
	pp = getmem(10);

	int main_a = 0;
	main_a = getA3();//main_a=temp;
	cout << "main_a" << main_a << endl;//10

	//int& main_a_re = getA3();//接收不到引用的值 
	//cout << "main_a_re" << main_a_re << endl;

	int& main_a_re = getA4();
	cout << "main_a_re" << main_a_re << endl;

	//引用当做函数返回值的话，函数可以做左值
	getA4() = 1000;
	return 0;
}

指针引用

#define _CRT_SECURE_NO_WARNINGS
#include<iostream>

 
using namespace std;

struct teacher
{
    int id;
    char name[64];
};

int get_mem(struct teacher** tpp)
{
    struct teacher* tp = NULL;
    tp = (struct teacher*)malloc(sizeof(struct teacher));
    if (tp==NULL)
    {
        return -1;
    }

    tp->id = 100;
    strcpy(tp->name, "tom");
    
    *tpp = tp;

    return 0;
}

void free_teacher(struct teacher**tpp)
{
    if (tpp==NULL)
    {
        return;
    }

    struct teacher* tp = *tpp;
    if (tp!=NULL)
    {
        free(tp);
        *tpp = NULL;
    }
}

int get_mem2(struct teacher*& tp)
{
    tp =(struct teacher*)malloc(sizeof(struct teacher));
    if (tp==NULL)
    {
        return -1;
    }
    tp->id = 100;
    strcpy(tp->name, "mike");
}
void free_mem2(struct teacher*& tp)
{
    if (tp!=NULL)
    {
        free(tp);
        tp = NULL;
    }
}
int main()
{
    struct teacher* tp = NULL;
    get_mem(&tp);
    cout << "id=" << tp->id << ",name=" << tp->name << endl;
    free_teacher(&tp);

    cout << "-------------------" << endl;
    get_mem2(tp);
    cout << "id=" << tp->id << ",name=" << tp->name << endl;

    return 0;
}

打印结果：

const引用

#define _CRT_SECURE_NO_WARNINGS
#include<iostream>


using namespace std;


int main()
{
	//1.如果针对一个常量进行引用，必须是一个const引用
	const int a = 10;

	const int& re = a;

	int b = 10;
	const int& re2 = b;//2.相反如果一个普通变量，用一个const引用接收是可以的

	cout << "b=" << b << endl;
	cout << "re2=" << re2 << endl;
	//ret2 = 300;//err
	b = 30;
	cout << "b=" << b << endl;
	cout << "re2=" << re2 << endl;

	return 0;
}

打印结果：