1.1
- 常量
const double Pi = 22.0 / 7;
1.2
- 常量表达式
constexpr double GetPi() {return 22.0 / 7;}
constexpr double TwicePi() {return 2 * GetPi;}
1.3.
- 枚举常量，变量只能取一组特定的取值时。
enum Directions{
north,
south,
east,
west
};
Directions Mydirection = west; // 这个枚举常量只能取前面指定的值
1.4
- 预处理器宏
- 只进行文本替换，编译器不知道变量类型，不推荐。
# define Pi 3.1415
2.1
- 数组：按一定顺序将一系列相同类型的数据存储到内存中
- 定义静态数组：包含的元素数和内存量都是固定的（即使有些元素未使用）
int Manynumbers [5] = {0}; //初始化为相同的值
int Manynumbers [5] = {2, 6, 11, 44, 43}; //初始化为不同的值
int Manynumbers [5] = {19, 12}; //初始化部分值
const int ARRAY_LENGTH = 5;
int Manynumbers [ARRAY_LENGTH] = {10};
- 数组长度定义为常量，需要在多个地方使用时很方便
int Manynumbers [] = {12, 13, 18}; //知道数组每个元素的初始值，可以不指定数组长度
2.2
- 多维数组
int Multiarray [2][3] = {{0, 1, 2}, {3, 4, 5}};
int Multiarray [2][3] = {0, 1, 2, 3, 4, 5};
- 内存是一维的，只是在模拟二维，所以这两种初始化是一样的
2.3
- sizeof运算符查看变量或类型占用内存数（字节数）
sizeof(variable)
sizeof(type)
sizeof(int); //4
sizeof(Manynumbers); //5*4=20
3.1
// switch-case
sitch(expresion){
case A:
Do;
break;
case B:
Do;
break;
default:
Do;
break;
}
3.2
- 三目运算符
int Bignum = (a > b)?a:b;
3.3
- 无限循环与控制无限循环
while(true){
Do;
if(expression)
break;
}
for(;;){
Do;
if(expression)
break;
}
do{}while(); //使用此循环时，
4.1
- 函数原型
double Area(double radius);//类型+函数名+形参列表(函数形参类似于局部变量，只能在函数内部使用)
- 函数定义
double Area(double radius){
return Pi*radius*radius;
}
- 带默认值的函数形参
double Area(double radius, double Pi = 3.14);
4.2
- 递归函数
- 可以内部调用自己的函数
- 明确的退出条件
- 斐波那契数列， F(0)=0,F(1)=1,F(2)=1,...,F(n)=F(n-1)+F(n-2).
int GetFib(int fibN){
if(fibN < 2)
return fibN;
else
return GetFib(fibN-1) + Get(fibN-2);
}
4.3
- 函数重载：函数名和返回类型相同，但参数不同的函数
double Area(double radius); //圆形面积
double Area(double radius, double height); //柱体面积
4.4
- 将数组传递给函数
int Mynumbers[] = {12,12,14,32};
void DisplayArray(int numbers[]/int[] numbers, int length){
for(int index = 0;index<length; ++length)
cout<<numbers[index]<<endl;
}
DisplayArray(Mynumbers,4);
4.5
- 按引用传递参数
double Area(double radius);
- 当main函数调用该函数时，不会影响main函数里面的radius值，因为Area使用的是包含值的拷贝
double Area(double& radius); //去这个值的地址
5.1
- 指针是一个变量，也占用内存空间，是一种指向内存的特殊变量
- 必须对指针进行初始化，否则包含的值是垃圾值
- 这些垃圾值非常危险，因为它们可能会导致程序访问非法内存单元
int Age = 24;
int* pint = &Age; // 引用运算符& 又称 取地址运算符
cout<<*pint; // 解除引用运算符* 又称 取内容运算符
5.2
- 动态内存分配
- 数组内存分配是静态和固定的，限制了程序的容量，降低了程序的性能
int numbers[100]={0}；
- 使用new来分配新的内存块，如果成功，会得到一个指针指向分配的内存
- new表示请求分配内存，但不总是会得到满足，取决于系统的状态
Type* pointer = new Type;
int* pnumber = new int; //得到指向一个int的指针
int* pnumbers = new int[10] //得到一个指向10个int的指针
- 使用new分配的内存最终都需要使用对应的delete进行释放,否则会导致内存泄漏
delete pnumber;
delete[] pnumbers;
5.3
- 递增递减用于指针
- 包含的地址将增加或减少指向的数据类型的sizeof()
int* pointer = &age;
++pointer = &age + sizeof(int)
5.4
const用于指针
const确保变量在整个生命周期都是初始值，不会改变
指针指向的值是常量，不能修改，但可以修改指针包含的地址
int Age = 24;
const int* pointer = &Age; //指针指向的内容永远不变，但指针地址可能会变
int height = 180;
pointer = &height //YES
*pointer = height //NO
- 指针指向的地址是常量，不能修改，但可以修改指针指向的内容
int Age = 24;
int* const pointer = &Age; //指针指向的地址永远不变，但指针指向的内容可能会变
int height = 180;
pointer = &height //NO
*pointer = height //YES
5.5
- 数组与指针
- 前面说的递增递减用于指针和这里非常相似
int Mynumbers[5] = {0};
int* Poniters = Mynumbers;
*(Pointers+1) == Mynumbers[1]
// Mynumbers就是一个指针，指向数组的第一个元素Mynumbers[0]
5.6
- 检查new发出的分配请求是否得到了满足
- 使用异常，如果分配失败将会引发bad_alloc异常，程序中断执行。
- 不使用异常，程序将被操作系统终止，显示不友好的界面
int main(){
try
{
int* Age = new int[1000];
...
delete[] Age;
}
catch(bad_alloc)
{
cout<<"memory allocation failed."<<endl;
}
return 0;
}
5.7
int* point = NULL; //point 是个指针，int* 是指针类型
int original = 12;
int& refere = original; //refere 是个引用，是后面变量的别名， int& 是引用类型
*point， &refere 里* &是操作符
const int& refere = original; //仅仅是别名，不能修改原始值
6.1
- 类类似于函数声明，本身并不影响程序的运行，而必须使用它
- 类是一组属性和操作这些属性的函数的集合
class Human
{
// 属性
string Name;
string DateofBirth;
string PlaceofBirth;
string Gender;
// 方法
void introduceself();
}
6.2
- 实例化对象，类是蓝图，本身不会有任何影响，对象是类的化身，要使用类的功能，必须实例化对象
- 和创建其他类型类似
int Pi = 3.1415;
Human Tom;
- 动态内存分配也类似
int* pointer = new int[5];
delete* pointer;
Human* phuman = new Human();
delete phuman;
6.3
- 访问类成员
- 属性和方法都是类的成员
Human Tom;
Tom.DateofBirth = "1994";
Tom.introduceself();
Human* PTom = new Human();
PTom->DateofBirth = "1994";
PTom->introduceself();
(*PTom).DateofBirth = "1994";
6.4
- 类能够让设计者控制类的属性的访问和操作的方式
class Human
{
private:
int Age;
string Name;
public:
int GetAge(){
return Age; //类内函数可以直接在内部访问类的属性
}
void SetAge(InputAge){
Age = InputAge;
}
}
Human Tom;
Tom.Age = 19; //返回一个错误，无法访问私有成员
// 但可以通过类的函数访问和控制，但这样对于管理者来说，是可控的行为。
6.5
构造函数：和类名相同，但没有任何返回值的函数
保证实例化对象时，属性成员不会是垃圾值
析构函数：与类同名，前面有个波浪号~
每将对象不在作用域内或通过delete删除时，都将调用析构函数
析构函数不能重载
class Human
{
private:
int Age;
string Name;
public:
Human(){
Age = 0;
}
Human(string HumanName){
Name = HumanName;
}
Human(string HuamnName, int HuamanAge){
Name = HuamnName;
Age = HumanAge;
}
~Human(){
}
}
6.6
- this指针包含当前对象的地址，值为&object
- 类成员方法调用其它成员方法或属性时，编译器会隐士传递this指针
class Human
{
private:
int Age;
string Name;
public:
int GetAge(){
return Age; //类内函数可以直接在内部访问类的属性
}
void SetAge(this, InputAge){
int OriginalAge = GetAge()
Age = InputAge; // this->Age = InputAge;
}
}
7.1
- 派生类继承了基类
