c++是一门广泛使用的计算机编程语言，刚开始学习 C++时， 我们需要认真学习 C++的基本语法规则，包括变量声明、数据类型、控制结构（如条件语句、循环语句）等。确保对每一个语法点都理解透彻，避免在后续编程中出现低级错误。注意 C++与其他编程语言在语法上的差异，比如 C++中的指针操作、引用等概念是一些其他语言中没有的，需要特别留意。
1.c++简单程序
C++兼容C语言绝大多数的语法，C++中需要把定义文件代码后缀改为.cpp，vs编译器看到是.cpp就会调⽤C++编译器编译，linux下要⽤g++编译，不再是gcc。
cpp
#include<stdio.h>
int main()
{
printf("hello henu\n");
return 0;
}当然C++有⼀套自己的输⼊输出，严格说C++版本的应该是这样写的。
cpp
#include <iostream>
using namespace std;
int main()
{
cout << "hellow henu" << endl;
return 0;
}2.命名空间
2.1namespace命名空间的价值
命名空间（namespace）可以避免命名冲突。在大型项目中，可能会有多个开发人员同时工作，或者使用来自不同库的代码。如果没有命名空间，不同模块中相同名称的标识符很容易发生冲突。例如：两个不同的函数库可能都定义了一个名为"func"的函数。使用命名空间后，可以分别通过不同的命名空间来访问这些函数，避免了冲突。
cpp
#include <stdio.h>
#include <stdlib.h>
int rand = 10;
int main()
{
// 编译报错：error C2365: "rand": 重定义；以前的定义是"函数"
printf("%d\n", rand);
return 0;
}2.2namespace命名空间的定义
（1）定义命名空间，需要使用到namespace关键字，后面跟命名空间的名字，然后接⼀对{}即可，{}中即为命名空间的成员。命名空间中可以定义变量/函数/类型等。
（2）namespace本质是定义出⼀个域，这个域跟全局域各自独立，不同的域可以定义同名变量
（3）C++中域有函数局部域，全局域，命名空间域，类域；域影响的是编译时语法查找⼀个变量/函数/ 类型出处(声明或定义)的逻辑，所有有了域隔离，名字冲突就解决了。局部域和全局域除了会影响编译查找逻辑，还会影响变量的生命周期，命名空间域和类域不影响变量生命周期。
（4）namespace只能定义在全局，当然它还可以嵌套定义。
（5）项目工程中多文件中定义的同名namespace会认为是⼀个namespace，不会冲突。
（6）C++标准库都放在⼀个叫std(standard)的命名空间中。
普通的命名空间定义：
cpp
#include <iostream>
using namespace std;
namespace henu
{
//命名空间中可以定义变量、函数、类型
int rand = 10;
int add(int x, int y)
{
return x + y;
}
struct Node
{
struct Node* next;
int val;
};
}
int main()
{
//这里访问的是全局变量中的rand函数指针
printf("%p\n", rand);
//这里指定henu命名空间中的rand
//域作用限定符"::"
printf("%d\n", henu::rand);
return 0;
}嵌套定义：
cpp
#include <iostream>
using namespace std;
namespace henu
{
namespace w1
{
int rand = 10;
int add(int x, int y)
{
return x + y;
}
}
namespace w2
{
int rand = 20;
int minus(int x, int y)
{
return x - y;
}
}
}
int main()
{
printf("%d\n", henu::w1::rand);//10
printf("%d\n", henu::w2::rand);//20
printf("%d\n", henu::w1::add(5, 3));//8
printf("%d\n", henu::w2::minus(5, 3));//2
return 0;
}多文件中可以定义同名namespace，它们会默认合并到一起，
2.3namespace命名空间的使用
编译查找⼀个变量的声明/定义时，默认只会在局部或者全局查找，不会到命名空间里面去查找。所以下面程序会编译报错。所以我们要使用命名空间中定义的变量/函数，有三种方式：
（1） 指定命名空间访问，项目中推荐这种方式。
（2） using将命名空间中某个成员展开，项目中经常访问的不存在冲突的成员推荐这种方式。
（3） 展开命名空间中全部成员，项目不推荐，冲突风险很大，日常小练习程序为了方便推荐使用。
错误使用：
cpp
#include <iostream>
using namespace std;
namespace henu
{
int x = 10;
int y = 20;
}
int main()
{
//报错,未定义标识符x
printf("%d", x);
return 0;
}指定命名空间访问：
cpp
#include <iostream>
using namespace std;
int main()
{
printf("%d", henu::x);
return 0;
}
//using 将整个命名空间展开
using namespace henu;
int main()
{
printf("%d ", x);
printf("%d ", y);
return 0;
}using 将命名空间中的某个成员展开:
cpp
#include <iostream>
using namespace std;
namespace henu
{
int x = 10;
int y = 20;
}
using henu::x;
int main()
{
printf("%d ", x);
return 0;
}3.c++输入和输出
（1）<iostream> 是 Input Output Stream 的缩写，是标准的输入、输出流库，定义了标准的输入、输
出对象。
（2）std::cin 是 istream 类的对象，它主要面向窄字符（narrow characters (of type char)）的标准输入流。
（3）std::cout 是 ostream 类的对象，它主要面向窄字符的标准输出流。
（4）std::endl 是⼀个函数，流插入输出时，相当于插入⼀个换行字符加刷新缓冲区。
（5） <<是流插入运算符，>>是流提取运算符。（C语言还用这两个运算符做位运算左移/右移）
（6）使用 C++输入输出更方便，不需要像printf/scanf输⼊输出时那样，需要手动指定格式，C++的输入输出可以自动识别变量类型(本质是通过函数重载实现的，这个以后会讲到)，其实最重 要的是 C++的流能更好的支持自定义类型对象的输入输出。
（7）cout/cin/endl等都属于C++标准库，C++标准库都放在⼀个叫std(standard)的命名空间中，所以要通过命名空间的使用方式去用他们。
（8）⼀般日常练习中我们可以using namespace std，实际项目开发中不建议using namespace std。
（9） 这⾥我们没有包含<stdio.h>，也可以使用printf和scanf，在包含<iostream>间接包含了。vs系列 编译器是这样的，其他编译器可能会报错。
cpp
#include <iostream>
using namespace std;
int main()
{
cout << "hellow henu\n";
cout << "hellow henu" << endl;
int a = 10;
double b = 0.1;
char c = 'x';
cout << a << " " << b << " " << c << endl;
//10 0.1 x
std::cout << a << " " << b << " " << c << std::endl;
//10 0.1 x
scanf("%d %lf", &a, &b);
printf("%d %lf\n", a, b);
//可以自动识别变量类型
cin >> a;//输入10
cin >> b >> c;//输入0.1,'x'
cout << a << endl;
cout << b << " " << c << endl;
//10
//0.1 x
return 0;
}4.缺省参数
（1）缺省参数是声明或定义函数时为函数的参数指定⼀个缺省值。在调用该函数时，如果没有指定实参则采用该形参的缺省值，否则使用指定的实参，缺省参数分为全缺省和半缺省参数。（有些地方也把缺省参数叫作默认参数）
（2）全缺省就是全部形参给缺省值，半缺省就是部分形参给缺省值。C++规定半缺省参数必须从右往左依次连续缺省，不能间隔跳跃给缺省值。
（3）带缺省参数的函数调用，C++规定必须从左到右依次给实参，不能跳跃给实参。
（4） 函数声明和定义分离时，缺省参数不能在函数声明和定义中同时出现，规定必须函数声明给缺省值。
代码1：
cpp
void fun(int a = 0)
{
cout << a << endl;
}
int main()
{
//没有传参，使用参数默认值
fun();
//传参，使用指定参数
fun(10);
return 0;
}代码2：
cpp
//全缺省
void fun1(int a = 10, int b = 20, int c = 30)
{
cout << "a = " << a << endl;
cout << "b = " << b << endl;
cout << "c = " << c << endl;
}
//C++规定半缺省参数必须从右往左依次连续缺省，不能间隔跳跃给缺省值
//半缺省
void fun2(int a, int b = 10, int c = 20)
{
cout << "a = " << a << endl;
cout << "b = " << b << endl;
cout << "c = " << c << endl;
}
//错误的
//void fun2(int a = 10, int b = 10, int c)
//{
// cout << "a = " << a << endl;
// cout << "b = " << b << endl;
// cout << "c = " << c << endl;
//}
int main()
{
fun1();//10 20 30
fun1(1);//1 20 30
fun1(1, 2);//1 2 30
fun1(1, 2, 3);//1 2 3
//错误的 fun(1, , 3);
//错误的 fun2();
fun2(100);
fun2(100,200);
fun2(100,200,300);
return 0;
}代码3：函数声明和定义分离时，缺省参数不能在函数声明和定义中同时出现，规定必须函数声明给缺省值。
cpp
typedef int STDataType;
typedef struct Stack
{
STDataType* a;
int top;
int capacity;
}ST;
void STInit(ST* ps, int n = 4);
// 缺省参数不能声明和定义同时给
void STInit(ST* ps, int n)
{
assert(ps && n > 0);
ps->a = (STDataType*)malloc(n * sizeof(STDataType));
ps->top = 0;
ps->capacity = n;
}
int main()
{
ST s1;
STInit(&s1);
// 确定知道要插⼊1000个数据，初始化时⼀把开好，避免扩容
ST s2;
STInit(&s2, 1000);
return 0;
}5.函数重载
C++支持在同⼀作用域中出现同名函数，但是要求这些同名函数的形参不同，可以是参数个数不同或者类型不同。 这样C++函数的使用就更加灵活。C语言是不支持同⼀作用域中出现同 名函数的。
cpp
//参数类型不同
int Add(int a, int b)
{
cout << a << " " << b << endl;
return a + b;
}
double Add(double a, double b)
{
cout << a << " " << b << endl;
return a + b;
}
//参数个数不同
void fun()
{
cout << "fun()" << endl;
}
void fun(int a)
{
cout << "fun(int a)" << endl;
}
void fun(int a, int b)
{
cout << "fun(int a, int b)" << endl;
}
//参数类型顺序不同
void fun(int a, char b)
{
cout << "fun(int a, char b)" << endl;
}
void fun(char a, int b)
{
cout << "fun(char a, int b)" << endl;
}
void Swap(int* a, int* b)
{
//...
}
void Swap(double* a, double* b)
{
//...
}
int main()
{
Add(10, 20);
Add(1.1, 2.2);
fun();
fun(10);
fun(10, 20);
fun(10, 'a');
fun('a', 10);
int a = 1, b = 2;
double c = 1.1, d = 2.2;
Swap(&a, &b);
Swap(&c, &d);
return 0;
}两个有误示例：
cpp
//返回值不同不能作为重载条件，因为调⽤时也⽆法区分
void fxx()
{
}
int fxx()
{
return 0;
}
下⾯两个函数构成重载
f()但是调⽤时，会报错，存在歧义，编译器不知道调⽤谁
void f1()
{
cout << "f()" << endl;
}
void f1(int a = 10)
{
cout << "f(int a)" << endl;
}
int main()
{
f1();
return 0;
}