在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;
}
打印结果：
#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;
}
打印结果：
