目录
扫描二维码关注公众号，回复：
3908618 查看本文章
1. C++ I/O方式
输入过程：输入设备 → 输入流 → scanf/cin → 变量
输出过程：变量 → printf/cout → 输入流 → 输出设备
输入/输出流的语法：
1. cout 语法的形式：
cout << a << endl;2. cin 语法的形式：
cin >> a;
cin >> a >> b;【注】与C语言相比的便利之处：
1） 不用关注占位符
2） 不用关注数据类型
【注】使用 cin、cout 必须增加头文件：
#include <iostream>2. 名字空间的定义
关键词：namespace
不同的名字空间（A，B）内允许有相同名称的变量（x，y）、函数（ fun() ）等。
namespace A
{
int x;
int y;
void fun();
void fun1();
}
namespace B
{
int x;
int y;
void fun();
void fun2();
}【注】调用名字空间的语句：
using namespace A;【注】调用名字空间内变量以及函数的方法：
A :: x;
A :: fun();3. 数据类型新成员
数据类型：
1. 基本类型：
整型 int；字符型：char；实型：单精度 float、双精度 double、常双精度 long double;
2. 构造类型：
数组类型；结构类型 struct；联合类型 union；枚举类型 enum；
3. 指针类型
4. 空类型（无值类型）void
（1）C++ 新类型 —— 布尔类型 bool
真：true 1；假：false 0；
bool flag = false;
if (flag)
{
//to do
}
else
{
//to do
}布尔（bool）类型的输出方式：
int main (void)
{
bool flag = false;
cout << flag <<endl; //输出 0
cout << boolalpha << flag << endl; //输出 false
return 0;
}
（2）随用随定义
int main (void)
{
cout << " x = ";
int x = 0;
cin >> x;
cout << " y = ";
int y = 0;
cin >> y;
cout << " x+y = " << x+y ;
return 0;
}4. 引用
C++ 中的引用就是变量的别名。
（1）普通类型引用的定义与使用
int maozi = 3;
int &mz = maozi;
mz = 4;
cout << maozi; //输出 4
maozi = 6;
cout << mz; //输出 6【注】无论是操作别名还是变量，只要其中一个发生变化另一个也随之发生变化。
（2）指针类型引用的定义与使用
bool *p = NULL; //定义布尔类型指针变量 p
bool *&q = p; //为布尔类型指针 p 取别名 qbool x = false;
bool *p = &x;
bool *&q = p;
x = true;
cout << boolalpha << *p; //输出 true
cout << boolalpha <<*q; //输出 true
*q = false;
cout << boolalpha << x; //输出 false
*p = true;
cout << boolalpha <<*q; //输出 true（3）引用作为函数参数
void fun(int &a, int &b)
{
int c = 0;
c = a;
a = b;
b = c;
}
int x = 10, y = 20;
fun(x, y);5. 函数的默认值以及重载
（1）默认值术语
缺省值 default / value
（2）函数默认值
void fun (int i, int j = 5, int k = 10)
{
cout << " i = " << i << " j = " << j << " k = " << k << endl;
}
int main ()
{
fun (20); //输出：i = 20 j = 5 k = 10
fun (20, 30); //输出：i = 20 j = 30 k = 10
fun (20, 30, 40); //输出：i = 20 j = 30 k = 40
return 0;
}【注】
1. 有默认参数值的参数必须在参数表的最右端。
int f(int a, int b = 0, int c); // 错误
int f(int a, int b = 0, int c = 0); // 正确2. 声明和定义同时给出默认值，有些编译器会报错，有些不会。所以最好只在函数声明时给出默认值。
代码演示：
#include <iostream>
#include <stdlib.h>
using namespace std;
void fun(int x, int y = 4, int z = 1);
int main(void)
{
int a = 10;
int b = 15;
fun(a, b);
system("pause");
return 0;
}
void fun(int x, int y, int z)
{
cout << "x = 0" << x << endl;
cout << "y = 0" << y << endl;
cout << "z = 0" << z << endl;
}
（3）作用域术语
void fun1 () //作用域为 fun1
{
int x;
}
void fun2 () //作用域为 fun2
{
char x；
}（4）函数重载
同一作用域下名字相同，参数不同的多个函数。
1）名字相同，参数的个数不同：
void fun ()
void fun (int x)
void fun (int x, int y)2）名字相同，参数类型不同：
void fun (int *p)
int fun (int &p)
int fun (int x = 0)重载总结：
1）重载函数的参数格式，参数类型，参数顺序3者中必须至少有一种不同，返回值不同不作为重载依据。
2）重载函数的功能应该相近，不为重载而重载。
3）main() 函数不能重载。
代码演示：
#include <iostream>
#include <stdlib.h>
using namespace std;
int max1(int x, int y);
int max1(int x, int y, int z);
int max1(int *p, int *q);
int main(void)
{
int a = 10;
int b = 5;
int c = 7;
cout << max1(b, c) << endl; //输出：7
cout << max1(a, b, c) << endl; //输出：10
cout << max1(&a, &c) << endl; //输出：10
system("pause");
return 0;
}
int max1(int x, int y)
{
return x > y ? x : y;
}
int max1(int x, int y, int z)
{
if (x > y)
{
if (x > z)
return x;
else
return z;
}
else
{
if (y > z)
return y;
else
return z;
}
}
int max1(int *p, int *q)
{
if (*p > *q)
return *p;
else
return *q;
//return *p > *q ? *p : *q;
}
6. 内存管理
内存的分类：
（1）栈区（stack）：有编译器自动分配释放；
（2）全局区/静态区（static）：存放全局变量、静态数据、常量；
（3）文字常量区：常量字符串存放在这里，程序结束后由系统释放；
（4）长须代码区：存放函数体的二进制代码；
（5）堆区（heap）：程序员申请/释放。
（1）内存管理
1）申请内存：new
int *p = new int;
int *p = new int(10); //*p = 10
int *p = new int[5]； //申请数组，大小为 52）释放内存： delete
int *p = new int; //申请
delete p; //释放
int *p = new int(10); //申请
delete p; //释放
int *p = new int[5]; //申请
delete []p; //释放3）判断申请内存的失败
int *p = new int[200];
if(NULL == p)
{
//内存申请失败
}4）释放内存完毕的后续工作
int *p = new int[200];
delete []p;
p = NULL;【注】内存管理罪与罚：当申请的内存忘记释放，就会产生内存泄漏。
代码演示：
#include <iostream>
#include <stdlib.h>
using namespace std;
int main(void)
{
/*int *p = new int;
if (NULL == p)
{
cout << "failed" << endl;
}
cout << "ok" << endl;
*p = 30;
delete p;
p = NULL;*/
int *p = new int[100];
if (NULL == p)
{
cout << "failed" << endl;
}
cout << "ok" << endl;
for (int i = 0; i < 100; i++)
{
p[i] = i;
}
delete []p;
p = NULL;
system("pause");
return 0;
}
（2）文件的读写
1）文件输出
#include <fstream>
using namespace std;
int main (void)
{
ofstream myFile("D:\\TEST\\1.txt"，ios::out); //打开文件 1.txt
myFile << "hello C++" << endl; //写入 hello C++
myFile.close(); //关闭文件
return 0;
}
2）文件输入
#include <fstream>
using namespace std;
int main (void)
{
char ch;
ifstream myFile("D:\\TEST\\1.txt"，ios::in); //打开文件 1.txt
myFile >> ch; //读出文件内容至 ch
myFile.close(); //关闭文件
return 0;
}
（3）文件打开方式
| ios::app | 将输出数据添加到文件的结尾 |
| ios::ate | 将一个文件打开作为输出文件，并转移到文件尾。可以在文件的任何位置写数据 |
| ios::in | 打开一个文件作为输入文件 |
| ios::out | 打开一个文件作为输出文件 |
| ios::trunc | 如果文件有内容则将文件内容丢弃（默认） |
| ios::binary | 打开一个文件进行二进制输入或输出 |
代码演示：
#include <fstream>
#include <iostream>
#include <stdlib.h>
using namespace std;
int main(void)
{
/*ofstream myFile("D:\\TEST\\1.txt", ios::out);
myFile << "hello C++" << endl;
myFile.close();*/
char ch[9];
ifstream myFile("D:\\TEST\\1.txt", ios::in);
for (int i = 0; i < 9; i++)
{
myFile >> ch[i];
cout << ch[i]; //输出：helloC++
}
myFile.close();
system("pause");
return 0;
}7.关键字 const
关键字：const
是 constant 单词的简写，是关键字的含义。可以通过修饰一个变量使其成为常量。
const int x = 0;
int const x = 0;
const int *p = 0;
int const *p = 0;
int *const p = 0; //修饰指针类型变量
const int *const p = 0;
int const *const p = 0;（1）const 修饰普通数据类型
int x = 0; x = 10; //正确
const int x = 0; x = 10; //错误
double y = 0.5； y = 1.8; //正确
double const y = 0.5; y = 1.8; //错误（2）const 修饰指针类型
int x = 0;
int y = 0;
int *p = &x; //定义指针变量 p，p 指向 x
*p = 3; //重新赋值
p = &y; //p 指向 y
int x = 0;
int y = 0;
int const*p = &x; //定义指针变量 p，p 指向 x 且不能重新赋值
*p = 3; //错误
p = &y; //p 指向 y
int x = 0;
int y = 0;
int *const p = &x; //定义指针变量 p，p 指向 x 且不能指向其他变量
*p = 3; //重新赋值
p = &y; //错误
int x = 0;
int y = 0;
int *const*p = &x; //定义指针变量 p，p 指向 x
*p = 3; //错误
p = &y; //错误
（3）const 修饰函数参数
int max (int x, int y)
int max (const int x, int const y) //在max函数内不会出现x， y赋值的情况
int max (int const*p, int *const q) //不改变 p 的值，且不指向其他地址