C++ 上篇

1.语言中的数据成分

2.语言中的运算成分

3.语言中的控制成分

4.语言中的传输成分 函数的传参机制

C++中的数据类型

   1.该类型的所占内存大小

   2.基于该类型的运算方法

   int i;  +-*/%

   float f; +-*/

   3.对数据类型进行检查

   3.14*2*2

关键字 32 19

   signed unsigned static

   sizeof   关键字 运算符

基本数据类型

   整形

       布尔    bool    1byte   8bit

       字符    char    1byte   8bit

       短整形  short   2byte   16bit

       整形    int     4byte   32bit

       长整形  long    4byte   32bit

   浮点

       单精度  float   4byte   32bit

       双精度  double  8byte   64bit

扩展数据类型

   数组    []

   指针    *

   void

   string

   自定义数据类型

       结构体  struct

       枚举    enum

       联合    union

       类      class

变量 -->内存空间

int a = 3+4;

变量名

   不能是关键字

   字母/_ + 字母/_/数字

   区分大小写

   abc   ABC

类型 变量名;

计算机对内存是如何管理组织的

   bit

   8bit    1byte   一个字节

   32/64   一个机器字  Byte

   1G = 1024M = 1024*1024K = 1024*1024*1024byte

   100Mbit/8   12M

   32计算机 访问的最大内存 G  

   4G

   2的32次方  = ?G

   2的10次方  = 1024

   1G=2的30次方

   1k = 1024byte

   1kg = 1000g

变量的输入 ,输出

   cout 输出流对象

   cin  输入流对象

   int a;

变量信息表示

   所有的整形，浮点，字符，图片，视频，语音

   man ascii

==============================================================

基于基本数据类型上的运算

   sizeof 变量 类型 常量

   sizeof(3.14) = 8

算术运算

   + - * / %

   n%7  ==> [0, 6]

   n%10 ==> [0, 9]

   n%32 ==> [0, 31]

   n = rand();

   n%32  [1-32]+

     32/7  [1-32]

     1.0-42亿

     n

   1.运算两边的类型不一致，如果不一致编译器会将其转换同一类型，运算后也是该类型

   2.编译器隐式转换规则

       a.整形转浮点

       b.小的转大的

       c.有符号转无符号

赋值运算 =

   将=右边的值 复制到=左边的变量（内存空间）中

   int i = 3.14;

   char c = i;

   i = 10; ==> 10 = i;

============================================================

关系运算

   > < >= <= != ==

分支语句

   if      单分支

   if(条件语句)

   {

       条件为真执行的语句

   }

   if(条件语句)        双分支

   {

       条件为真执行的语句

   }

   else

   {

       条件不为真执行的语句

   }

   switch case         多分支

   switch(条件)

   {

       case 1:

           break;

       case 2:

           break;

       default:

   }

gg=G 对整个代码进行缩进

逻辑运算

   && || ！

==============================================================

自增自减

   ++ --

   i++ ==> i = i + 1

   前置    先自增自减，再赋值使用

   后置    先赋值使用，后自增自减

循环语句

   for(三条语句，由两个分号分隔)

       1.第一条语句，循环变量初始化语句

       2.第二条语句，循环条件语句

       3.第三条语句，循环变量修改语句

   for(int i = 0; i < 100; i++)

   {

       循环条件为真，需要循环执行的语句

   }

   注意：

       1.for()后没有分号

       2.for后面的循环体，如果有多条语句用{}括起来

       3.for()中可以没有语句，里面一定要有分号

       for(;;) ==> 死循环

       break;  循环体中只要执行到break语句，整个循环结束

数组

   int a[10];

   a[0]

   ...

   a[9]

   a[10] 段错误或不确定值

   变量没有初始化，里面的值是不确定的

===============================================================

以窗口方式打开终端 Ctrl + Alt + t

以标签方式打开终端 Ctrl + Shift + t

切换标签 Alt + 数字

补全 tab

终止当前终端的程序 Ctrl + c

1.多个.cpp文件编程

   函数

   实现两个数的和

1.数据成分

2.运算成分

3.控制成分

4.传输成分

 模块之间的数据传递

 

   函数之间的数据传递

       局部变量：声明在函数内部的变量/{}内部的变量

           只能被当前函数所访问==》作用域

           生命周期==》内存什么时候产生，什么时候释放

           {}进入大括号    退出大括号

       全局变量：不在函数内部声明的变量

           能被当前文件所有函数所访问==》作用域

           整个程序==>当程序运行的时候，开始

                      当程序结束的时候，释放

   函数的传参机制

       1.传值

           函数的内部语句，要修改函数外部变量的内容 ？

       2.地址 ==>指针

           int i = 10;

           &i

           int *pi = &i;  // 指针变量

       3.数组

       4.引用 ==>

   文件之间的数据传递 ==>多文件编程

===============================================================

库 .o

   printf()-->printf.o-->libc

动态内存分配

   标准C库函数

   malloc  ==> new

   free    ==> delete

   sizeof

===============================================================

struct声明的成员和函数，默认为public 公开

class声明的成员和函数，默认为private 私有

成员变量：属性

成员函数：方法/行为

函数的默认参数

   声明函数的时候，加默认参数

   定义函数的时候，不需要指定默认参数

   如果没有实参，使用默认参数的值

   如果有实参，使用实参的值

   默认参数可以赋值为全局变量，全局表达式，函数调用

   有默认参数的形参必须在最右边

函数的重载

   函数名相同，形参类型不同，这样的函数形成重载

   函数名相同，形参个数不同，这样的函数形成重载

   函数名相同，返回值类型不同，这样的函数不能形成重载

回顾：

   类 和对象

   构造函数

       没有返回值

       函数名跟类名一致

       可以重载

       如果用户没有自定义一个拷贝构造函数，

       编译器会准备一个默认的拷贝构造函数

   析构函数

=================================================================

回顾：

今天：

   拷贝构造

   系统默认的为浅拷贝

   可以自定义一个深拷贝

   对象指针

   对象数组

   this 指针

   静态成员static（静态数据成员，静态函数成员）

   static 修饰变量：

           局部变量：作用范围限定在当前作用域{},

                     生命周期是整个程序的生命周期

           全局变量：生命周期是整个程序的生命周期,

                     作用范围只限定于当前文件访问

                     不会对其他文件的命名产生冲突，

                     不污染全局命名的空间

         

           修饰函数：生命周期是整个程序的生命周期

                     作用范围只限定于当前文件访问

                     不污染全局命名空间

    类 成员

    static  成员变量

               存储特性跟static修饰的局部变量一样，

               全局生命周期，即可以通过类名作用域访问，

               也可以通过对象访问

               Student::count;

               Student s;

               s.count

   static 成员函数

               静态成员函数只能操作静态成员变量，

               没有this指针，不能操作普通成员变量

   友元

       友元函数

       友元类

==================================================================

继承 extends

   类一般声明方式：

       class 类名 ：<继承方式> <基类>{

       <访问属性> public private protected(没讲)

       声明一个类的时候，没有说明访控属性，默认是什么？

       class   ==> private

       struct  ==> public

       };

       有哪些<继承方式>：public private protected

       如果没写继承方式，默认的继承方式是private

父类的访控属性      继承方式        子类的访控属性

public              public          public

protected           public          protected

private             public          不可访问

--------------------------------------------------

public              private         private

protected           private         private

private             private         不可访问

--------------------------------------------------

public              protected       protected

protected           protected       protected

private             protected       不可访问

--------------------------------------------------

总结：

   1.父类是private，无论通过什么方式继承，子类均不可访问

   2.无论父类public或protected，经过private，子类都是private

     无论父类public或protected，经过protected，子类都是protected