C++复习资料

第二次课

一定要动手编程序！！！！

七个题

2个程序填空

2个改错

3个编程

例1：交换两个数。

符号的操作？？

=   把右边的值赋给左边的变量

== 比较两边的大小

1变量的作用域：变量的作用范围

全局变量：

   定义在函数的外部

||=== Build: Debug in 2 (compiler: GNU GCC Compiler) ===|

D:\first\2\main.cpp||In function 'int main()':|

 

D:\first\2\main.cpp|9|error: 'b' was not declared in this scope|

D:\first\2\main.cpp||In function 'void print()':|

D:\first\2\main.cpp|13|warning: unused variable 'b' [-Wunused-variable]|

||=== Build failed: 1 error(s), 1 warning(s) (0 minute(s), 0 second(s)) ===|

局部变量：函数内部定义的变量

  特殊情况：函数内部语句块里定义的变量，块作用域

注意：全局变量少用。

2 同名覆盖

3 常量

   字面常量  35

   符号常量  const float pi=3.14

4 生命期

   动态变量  auto

   静态变量  static

5 运算符和表达式

  运算符：操作

1. 操作意义
2. 运算对象（单目、双目、三目）
3. 优先级
4. 结合性（数学里没有用过）

  表达式：用运算符连接起来的式子

算术运算符

+ - * / %

/

整除，除

上下文  

%

运算对象一定是整数

3%4

例2 把一个四位整数逆序

1234 –》4321

认识数

 记数系统

数码：0-9

基：数码的个数

位权：

进位规律

表示法：并列式，权展开式

1*103+2*102+3*101+4*100=1*1000+2*100+3*10+4*1=1234

关系运算：

>  >= < <=  ==  !=

运算结果是逻辑值（真 true  1 假 false  0）

逻辑运算

&& ||  ！ 逻辑与   逻辑或  逻辑非

&&  两个都真，结果为真，其余都是假

||  两个都假，结果为假，其余都真

！  假变真，真就变假

分段函数

判断闰年

能被4整除并且不能被100整除或者能被400整除  year

条件运算符 ？ ：

/*if( x >= 0)

        y = x;

    else

        y = -x;*/

 y = (x >= 0 ? x : -x);

++  --

||=== Build: Debug in 2 (compiler: GNU GCC Compiler) ===|

D:\first\2\main.cpp||In function 'int main()':|

D:\first\2\main.cpp|9|error: lvalue required as increment operand|

||=== Build failed: 1 error(s), 0 warning(s) (0 minute(s), 0 second(s)) ===|

运算对象要是变量

++放在前面，先自增1，再参与其他运算

++放在后面，先参与其他运算，再自增1.

累加

类型转换

一定要关注数据类型！！！！

显式转换（手工）

隐式转换（自动）

建什么样工程

建什么样的文件

第三次课

一定要动手编程序！！！！

sqrt  square root

运算符

表达式语句、控制语句、函数调用语句、空语句、复合语句

1 空语句

;

2 函数调用

这个函数有几个参数

函数来源：一种是自定义函数

          另一种库函数

3 复合语句

{}

4 表达式语句（上一节课学的内容）

5控制语句

三种基本结构：

顺序结构

选择结构

单分支if   

双分支 if  else

多分支if  else if   else

嵌套

开关语句switch  case

循环结构

    当型循环  while

直到型循环： do-while

计数型循环：for

break

continue

return

goto

算法都是由这三种结构来完成。

例1求一个数的绝对值

四种方法：

  1 两个单分支

  2 一个双分支

  3 默认+一个单分支

  4 条件表达式

Switch  case  可枚举的值

if嵌套：

else匹配原则：

先找第一个else

网上匹配最近没有匹配的if

例2 累加，累乘  累加乘

列表  元组  字典

例3编写一个程序，显示前50个素数，要求分5行显示，每行10个数字。

第一步：

写判断一个数是否为素数

第二步：

找出2-100之间的素数

第三步：

计数输出50个

第四步：

每行输出10，输出50个

算法：

迭代法：（本次循环和下次循环的关系）

牛顿迭代法 求方程的根

求两个数的最大公约数？

第四次课

一定要动手编程序！！！！

哥德巴赫猜想：

一个大于4的偶数，一定能分解成两个素数的和

我们已经有了实现三种基本结构的语句

顺序

选择结构

if

if   else

if  else if else

switch

case

循环结构

while

do  while

for

break

continue

每行要做三件事

打空格，打星，打回车

统计：

找最大（小）

打擂台

求平均（总和）

累加

排序

bubble

基于交换的排序

交作业：排序，插入排序

数据结构：排序(冒泡，插入，希尔排序，归并)

查找（二分查找）

字符数组本身和其他的数组没有差别

字符数组里存放是字符串就有差别！！！！

判断依据：最后有没有字符串的结束标志‘\0’

如果是字符串就可以整体输出

数组名表示是一个常量!!!

str   copy =strcpy

str  compare=strcmp

例1：排序4个字符串

china

hello

good

email

思考的第一问题：

怎么存储这4个字符串 =》 用一个二维字符数组

第二问题

怎么排序   bubble

第三问题

注意字符串的操作，当成一个整体

strcpy,strcmp,strcat,strlen     string.h

第五次课

一定要动手编程序！！！！

1数组

这个类型很重要

2字符数组和字符串

判断是不是字符串，后面有没有‘\0’

3字符串的类型

string

类类型

类类型定义的变量，叫对象

两个东西：

属性(变量)+方法（函数）

定义变量

写语句（算法）

函数

类（变量+函数）

4数据类型，用来描述数据的，支持的类型越多，那么它描述数据的能力就越强

  简单数据类型：int,char,float,double,bool

  复合类型：数组（相同类型的数据）嵌套的定义

            结构体（不同的类型）

dataframe  数据框：python,R

第一步：

   定义结构体（保存一行）

第二步

   定义结构体数组（保存多行）

定义类型的时候：不能放数据

定义变量：放数据

male

female

成员操作符

冒泡算法：

1. 简单的数据的数组
2. 字符串数组
3. 结构体数组

函数：

  首先不是数学函数

  程序段，一定的结构，完成一定的功能

例1：求两个数的最大公约数 辗转相除

关心：输入   两个整数  （你给的）

输出   一个整数 （最大公约数）

难点：要抽象

头部+函数体

头部：返回值类型   函数名  函数的形参

执行过程：

  调试可以看到

第六次课

一定要动手编程序！！！！

1先定义，后引用

函数声明：函数的头部+“；”

2

int lengthA = sizeof(a) / sizeof(a[0]);

数组元素的个数=数组总的字节数÷元素的字节数

3函数调用

传值

第一种：传值，无法交换，但是内部a,b两个数的值交换了。

void swapp(int a,int b){

   int t;

   t = a;

   a = b;

   b = t;

}

第二种传递参数，引用：定义一个别名，和一个已知的变量进行绑定。可以交换

void swapp(int &a,int &b){

   int t;

   t = a;

   a = b;

   b = t;

}

第三种：传地址，可以交换两个数

指针变量：本质是变量，存放地址

变量的指针：本质是常量，变量的首字节的地址（编号）

& 取地址符，取变量的地址

* 取内容运算符，间接访问运算符

void swapp(int *a,int *b){

   int t;

   t = *a;

   *a = *b;

   *b = t;

}

数组名是常量，就是数组的指针

4数组的访问

1. 下标法
2. 指针法（指针不移动）
3. 指针法（指针移动）

int a[]={1,2,3,4,5,6,7,8};

a[i] 与 *(a+i) 等价

int main() {

    int a[]={1,2,3,4,5,6,7,8};

    int i;

    int *t;

    for(i=0;i<8;i++)

        cout<<a[i]<<"\t";

    cout<<endl;

    for(i=0;i<8;i++)

        cout<<*(a+i)<<"\t";

    cout<<endl;

    t = a;

    for(i=0;i<8;i++)

        cout<<*t++<<"\t";

    cout<<endl;

}

a[i][j] 与 *(*(a+i)+j)等价

数组的递归定义：二维数组可以看成是一个一维数组的一维数组

指向元素的指针：指向一个元素

行指针：指向二维数组的一行。

二维数组的数组名就是一个行指针

int a[3][4] 

  行指针：a ,  a+1,a+2

  列指针：a[0],a[1],a[2]

int main() {

    int a[][3]={1,2,3,4,5,6,7,8,9};

    int i,j;

    int *t;

    int (*s)[3];

    for(i=0;i<3;i++){

        for(j=0;j<3;j++)

            cout<<a[i][j]<<"\t";

        cout<<endl;

    }

    for(i=0;i<3;i++){

        for(j=0;j<3;j++)

            cout<<*(*(a+i)+j)<<"\t";

        cout<<endl;

    }

    t = a[0];

    for(i=0;i<3;i++){

        for(j=0;j<3;j++)

            cout<<*t++<<"\t";

        cout<<endl;

    }

    s = a;

    for(i=0;i<3;i++){

        for(j=0;j<3;j++)

            cout<<*(*s+j)<<"\t";

        cout<<endl;

        s++;

    }

}

4 数组作为函数的形参本质是一个指针变量

void calYang(int a[][3])    //int (*a)[3]

5 递归      （牛顿迭代法）

定义：一个函数直接或间接调用了它本身。

递归出口：一定要有递归出口。

过程：两个过程：前推，回推。

计算的规模逐步变小，达到递归的出口。

跟数学递推类似。

初值

递推式

对树的操作，会用到递归（数据结构）

#include<iostream>

#include <cstring>

using namespace std;

int facc(int n);

int main() {

    cout<<facc(5)<<endl;

}

int facc(int n){

  if(n==0 || n==1)

     return 1;

  else

     return n*facc(n-1);

}

字符串逆序

#include<iostream>

#include <cstring>

using namespace std;

void reverseStr(char str[]);

void reverseR(char str[],int h,int t);

int main() {

    char str[]="hello world!";

    reverseStr(str);

    cout<<str<<endl;

}

void reverseStr(char str[]){

   int h,t,i,len;

   char c;

   len = strlen(str);

   h = 0;

   t = len-1;

   for(i=0;i<len/2;i++){  //str[i]   str[len-i-1]

      c = str[h];

      str[h] = str[t];

      str[t] = c;

      h++;

      t--;

   }

}

void reverseR(char str[],int h,int t){

   char c;

   if(h > t)

      return;

   else {

      c = str[h];

      str[h] = str[t];

      str[t] = c;

      reverseR(str,h+1,t-1);

   }

}

第九次课

一定要动手编程序！！！！

考试题型（校内机房）

1程序填空

2 程序改错

3编程

1运算符的重载（成员函数，友元函数）

2 继承

3 多态（静态多态和动态多态）

4 实现（接口）

面向对象的三个基本特征：

封装性

继承

多态

对象之间的关系：（依赖，关联，泛化，实现）
 继承

实现

组合

聚合

设计：UML建模语言，（软件工程）面向对象

类   对象

属性

方法

静态多态，早绑定（编译时）

  函数重载

  运算符重载

动态多态，迟绑定（运行时）

1运算符重载

（深拷贝，浅拷贝）属性是字符串的指针变量

  成员函数实现，形参个数比运算符对象的个数减一（自己是一个运算对象）

友元函数：形参的个数与运算符对象的个数相等

2继承

基类  父类

派生类  子类

重写

冒号后面是初始化构造列表

父类可以两个或两个以上，多继承（二义性）

3 动态多态

1）指针

2）virtual

3）公有继承

线程类（java）

Thread

run

4 实现：

纯虚函数

抽象类

接口

好处就是：如果父类无法实现某个功能，就可以把这个功能定义为一个纯虚函数，继续开发其他的功能。

比如：Thread类，线程管理功能父类都能实现，但进程去做的业务无法预知，就可以写一个纯虚的run方法，去完成进程的管理。

如果要用线程，你只要实现run方法。

5组合

注意与聚合差别