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