c到c++过度 第五天笔记

代号3

427笔记
STL
STL vector（动态数组 容器）
                增删查改
UML
                类和类之间的关系
                使用图形化描述类和类之间的关系
控制台编程
                光标属性
                                大小
                                是否隐藏
                                光标坐标
                控制台输出文本颜色设置
               
STL
        标准模板库        包含大量数据结构和算法部件
                                                        高可重用性 大量使用模板技术（泛型化编程）
                                                        c++标准一部分  不需要额外安装
        使用时机
                                操作大量元素时使用某种容器
                                c只有一种内置容器 数组  但数组必须提前确定大小 仅能保存数组 不能支持数据操作
        部件
                        容器
                                        存放数据的位置
                                        动态数组 栈~~~
                        算法
                                                方便对容器中的数据进行各种操作
                                                如排序 查找MAX元素
                        迭代器
                                        泛化指针类型
                                        若迭代器指向了容器中某个成员 迭代器将可以通过自增自减遍历容器中所有的成员
                                       
                                        联系容器和算法的媒介 算法操作容器的接口
        使用  后附代码示例
                        标准头文件名称和容器名一致
                        #        include<vector>
                        using std::vector
                       
                        容器都是基于模板实现        使用前必须先指明模板
                       
       

#include<iostream>
                        #include<vector>
                        using namespace std;
                        int main()
                        {
                                vector<int> nVec;
                                vector<double> dVec;//定义对象
                                
                                nVec.push_back(1);//添加新元素
                                
                                vector<int>::iterator itr;//获取元素迭代器
                                
                                itr=nVec.begin();//bigin返回是第0个元素的迭代器
                                
                                nVec.insert(itr+2,5)//插入数据：形参1：迭代器用于表示位置 形参2：要插入的数据
                                
                                int nVal=nVec[0];//取值                                                        访问动态数组中的元素
                                nVec[1]=100;
                                
                                nVal=nVec.at(1);//访问动态数组中的元素 使用at（）
                                nVec.at(0)=1011;
                                
                                for(int i=0;i<nVec.size();i++)                                                                //查找：1·遍历vector查找指定的数据
                                        {                                                                                                                                                        //vector.size()得到元素个数
                                                        if(nVec[i]==2)
                                                        {
                                                                cout<<"元素2在下标"<<i<<endl;
                                                                break;
                                                        }
                                        }
                                        
                                for(auto itr=nVec.begin();        itr!=nVec.end();++itr)                //2·循环从0元素的迭代器开始        
                                {                                                                                                                                                                                        循环自增迭代器 迭代器指向下移                
                                                cout<<*itr;                                                                                                                                        end（）返回值是最后一个元素的下一个        
                                                if(*itr==8)                                                                                                                                                位置
                                                {                                                                                                                                
                                                        itr=nVec.erase(itr);                                                                                                                ？？野指针 置空end（）
                                                        break;                                                                                                                        //
                                                }
                                }                
                        }
                        

        vector（动态数组） 拥有拓展功能 连续存储空间
                       
                        支持[]符号快速随机访问 由于连续存储空间 在插入删除操作方面 效率比较慢
               
                成员
                        增        push_back                 在末尾添加一个元素
                                        insert                                插入一个元素
                                       
                        删        pop_back                删除最后一个元素
                                        erase                                删除某个元素
                       
                        查        size                                        得到字符串的大小       
                                        empty                                判断是否为空
                                        []                                                返回元素
                                        =                                                复制副本
                        其他
                                        重载运算符
                                        []  = > < >= <= != ==  
                       
                clear函数后遗症                                                                                                                       

#include <iostream>  
                #include <sstream>  
                #include <string>  
  
                using namespace std;  
  
                int main()  
        {  
                        stringstream ss;  
                        int i = 0;  
                        for(i = 0; i < 5; i++ )  
                {  
                        ss << "hello";  
                        string s = ss.str();  
                        cout << s.size() << endl;  
          
                        // 如下两部可彻底恢复ss  
                        ss.clear(); // 恢复状态  
                        ss.str(""); // 恢复值                  精髓                                 
                }  
        } 
                        

                       
        示例                                          //代码在上
                增加元素
               
                        获取元素迭代器（定义对象 （迭代器））
                        vector<类型>  迭代器名
                       
                插入数据
                        形参1        迭代器 用于表示位置
                        形参2        要插入的数据
                       
        查找
                数组                                vector遍历                                vector.size()获取元素个数
               
                迭代器将可以通过自增自减遍历容器中所有的成员   
                end（）指向最后一个元素的下一个位置（无效位置）                                       
                       
                itr是一个指向元素的迭代器（指针）可以使用*运算符来取得指向的内容（元素的地址）
               
        删除
       
        输出所有
       

for(double &val:dVec)  auto 自动类型（变量自适应）
                        {
                                        cout<<val<<',';
                        }
                        cout <<endl;

                       
                       
类与类的关系
       
        继承
                       
        组合
                       
        友元
       
                1)C++中引入友元函数，是为在该类中提供一个对外（除了他自己意外）访问的窗口;
                2)这个友元函数他不属于该类的成员函数，他是定义在类外的普通函数，
                只是在类中声明该函数可以直接访问类中的private或者protected成员               

                friend <返回类型> <函数名> (<参数列表>);
               
        使用友元函数注意的要点：

                        类中通过使用关键字friend 来修饰友元函数，但该函数并不是类的成员函数，其声明可以放在
        类的私有部分，也可放在共有部分。友元函数的定义在类体外实现，
        不需要加类限定。
       
                        一个类中的成员函数可以是另外一个类的友元函数，而且一个函数可以是多个类友元函数。

                        友元函数可以访问类中的私有成员和其他数据，但是访问不可直接使用数据成员，
        需要通过对对象进行引用。

                        友元函数在调用上同一般函数一样，不必通过对对象进行引用。       
               
UML图描述类
        UML   统一建模语言
       
        功能模型
                        用户角度展示系统功能
                        直观展示程序功能
       
        对象模型
                        采用对象 属性（成员变量） 操作（成员函数） 关联等概念展示系统的结构和基础
                        程序员角度分析程序功能
                                一个项目中的对象 属性 操作
       
        动态模型
                        展示系统的内部行为
                                展示每个方法的具体实现
                                伪代码示意
                               
        类图
                        描述系统中所包含的类以及它们之间的相互关系
                        帮助人们理解项目
                       
                类                        使用包含类名 属性 操作且带有分隔线的长方形来表示
                       
                        类名       
                                        必须有一个名字 字符串
                        属性
                       
                        成员变量
                                       
                                        可见性(访问控制符) 名称：类型[=默认值]
                                                公 +
                                                保 -
                                                私 #
                                               
                        操作
                                        可见性 名称（参数列表）[:返回值类型]
                                       
        关系
                        关联 类与类之间最常用关系                                        类属性
                                                结构化关系
                                                通常将一个类的对象作为另一类的成员量
                                               
                                        单向关联
                                                用带箭头的实线表示
                                               
                                        双向关联
                                                实线
                                                eg：班级类与学生类
                               
                                        自关联
                                                                                                //百度补充
                                                类的属性类型为类本身
                                               
                                        多重性关联
                                                                                                        //百度补充
                                                一对多
                                                eg：一个班级可以有N个学生 但一个学生只有一个班级
                               
                                聚合（弱性关联）
                                        成员变量关系       
                                        整体与部分可分离        各自拥有生命周期
                                        部分可以属于多个整体对象 可以为多个整体对象共享
                                                eg：计算机与CPU         公司与员工
                                                                class A {...}
　                                                        class B { A* a; .....}
                                                                即类B包含类A的指针；
                                组合
                                        实心菱形（强性关联）
                                        eg：class A{...}
　                                                class B{ A a; ...}
                                                        即类B包含类A的对象。
                                                共享内存 A毁B毁
                               
                                        组合是关联关系的一种特例,体现是"包含一种XXX "的关系，        这种关系比聚合更强，
                也称为强聚合；他同样体现整体与部分间的关系，但此时整体与部分是不可分的，整体的
                生命周期结束也就意味着部分的生命周期结束；
                                        比如你和你的大脑；表现在代码层面，和关联关系是一致的，只能从语义级别来区分；       
                       
                        依赖                假设A类的变化引起了B类的变化，则说B类依赖于A类。
                                        虚线箭头                        成员函数参数
                                依赖关系有如下三种情况：
                                        1、A类是B类中的（某中方法的）局部变量；
                                        2、A类是B类方法当中的一个参数；
                                        3、A类向B类发送消息，从而影响B类发生变化；
                                使用关系是具有偶然性的、临时性的、非常弱的，但是B类的变化会影响到A；
                         
                                       
                        泛化        A是B和C的父类，B,C具有公共类（父类）A，说明A是B,C的一般化（概括，也称泛化）
                                        继承关系
                                        基类与子类关系
                                       
                        接口与实现
                                        带空心三角形的虚线
                                        接口使用抽象类实现（有纯虚函数的类）

        UML中,变量的定义形式为 :
                        变量名 : 变量类型 = 初始值.
                        eg：
                        定义成员变量:
                                m_x : int = 0
                                m_y : int
                        定义函数
                                move(x : int , y : int ) : int   等价于C中的 int move(int x , int y);       
                               
控制台编程
               
                头文件
                                #include<windouws.h>
                               
                        第一个参数为句柄 this指针
                                       
                                        标准输出句柄
                                                专门控制输出 光标位置 文字颜色
                                        标准输入句柄
                                                捕获鼠标在控制台中的坐标
                                                捕获按键
               

void show(HANDLE hStdOut,
                                                                        const char* pStr,
                                                                        SHORT x,SHORT y,
                                                                        WORD color=0x0A(0x后面两位十六进制分别设置前后背景色)）
                                                {
                                                                SetConsoleCursorPosition(hStdOut,{x,y});
                                                                SetConsoleTextAttribute(hStdOt,color);
                                                                cout<<pStr;
                                                }
                                int main()
                                {
                                                获取控制台操作句柄
                                                
                                }
                设置光标属性
                
                        语法
                        
                                参数 输出句柄        
                                
                        可见性和大小
                        
                        光标的坐标                
                
                
                设置文字颜色
                // 设置控制台光标信息(可见性,大小)
        CONSOLE_CURSOR_INFO cci = { 0 };
        cci.bVisible = FALSE;
        cci.dwSize = 5;
        SetConsoleCursorInfo(hStdOut,
                                                 &cci );

        cout << "HHHHH";
        COORD pos = { 10,10 };
        SetConsoleCursorPosition( hStdOut ,
                                                          pos );
        cout << "HHHHH";

        // 设置文字颜色
        SetConsoleTextAttribute( hStdOut ,
                                                         0x0A );

        for( int i = 0; i < 16; ++i ) {
                for( int j = 0; j < 16; ++j ) {
                        WORD color;
                        // i作为背景色
                        // j作为前景色
                        color = (i << 4) | j;
                        // 设置颜色
                        SetConsoleTextAttribute( hStdOut ,
                                                                         color );
                        cout << "■";
                }
                        
                

本次为笔记最后一次更新 以后转为发经验总结之类的以点破面为目标的帖子 坚持ING~