常识点滴积累

最新推荐文章于 2020-07-05 09:52:16 发布

月落乌啼silence

最新推荐文章于 2020-07-05 09:52:16 发布

阅读量2.3k

点赞数

分类专栏：小常识 Linux

本文链接：https://blog.csdn.net/qq_18293213/article/details/80868192

版权

Linux 同时被 2 个专栏收录

15 篇文章 0 订阅

订阅专栏

小常识

9 篇文章 0 订阅

订阅专栏

一些常识性的东西，用的时候需要查资料，比较麻烦，就在这记录一下，为了以后的方便。

4、linux下在当前目录下根据文件名查找文件：

find | xargs grep tree

这样可以在当前目录以及子目录下寻找文件名中有tree关键字的文件

ll | grep tree

只能在当前目录下寻找，不能递归的查找子目录下的文件。

1、linux下解压gz文件，gzip -d filename 把文件解压到当前文件夹

解压rar文件，rar e xxx.rar 解压至当前文件夹　

rar x xxx.rar 解压至xxx文件夹

2、python执行linux命令，最简单的方法 os.system(commond)即可。

3、htop的一些解释

左上角是cpu的使用情况，mem为内存的使用情况，swap为交换空间的使用情况。

右上角tasks为进程总数，以及当前运行的进程数 load average为最近1分钟，5分钟，10分钟的平均负载情况。

uptime为系统运行时间

下面从左至右分别为：

PID：进程的标识号

USER：运行此进程的用户

PRI：当前进程的优先级

NI：当前进程的优先级别

VIRT：当前进程占用的虚拟内存

RES：当前进程占用的屋里内存

SHR：当前进程占用的共享内存

S：当前进程的状态 R表示正在运行 S表示休眠状态 Z表示僵死状态

CPU%：当前进程占用CPU的使用率

MEM%：当前进程占用的物理内存占总内存的比例

TIME：该进程启动后占用CPU的时间

Commond：进程启动的命令。

c++:

一、c++判断一个数字是否在vector中，

要先引入

#include <algorithm> //sort函数、交并补函数
#include <iterator>

find(tmp.begin(), tmp.end(), pHead2->m_Value) != tmp.end() 满足这个条件就是在tmp中

判断字符是否在字符串中：

str2.find(s[i]) != str2.npos

满足这个条件就是s[i]在字符串str2中。

c++删除vector中指定的元素：

vector<int>::iterator it = nums.begin();
nums.erase(it);

删除nums中的第一个元素

C++字符串str中删除指定的字符：

str.erase(remove(str.begin(), str.end(), '"'), str.end());

要提前引入#include<algorithm>

c++中static关键字的作用：

在c语言中，static具有一下几个特点：

（1）定义全局静态变量：在全局变量上加上static关键字，改全局变量就成了全局静态变量，具有如下特点：

在全局数据取分配内存

如果没有初始化，默认为0

该变量在本文件内从定义开始到文件结束可见

（2）定义局部静态变量：在局部变量上加上static关键字，具有如下特点：

在全局数据区分配内存

如果没有初始化，默认为0

它始终驻留在全局数据区，直到程序运行结束

其作用域为局部作用域，当定义它的函数或语句块结束时，其作用域随之结束。

（3）定义静态函数

静态函数只能在本源文件中使用

在文件作用域中声明的inline函数默认为static

在c++中，具有如下特点:

内存分配：在程序的全局数据区分配

初始化和定义：静态数据成员定义时要分配空间，所以不能在类声明中初始化（但是static const 可以在类的定义中初始化）

静态成员函数。静态成员函数与类相联系，不与类的对象相联系。静态成员函数不能访问非静态数据成员。原因很简单，非静态数据成员属于特定的类实例，静态成员函数主要用于对静态数据成员的操作。静态成员函数不能被声明为const，和虚函数，静态成员函数是类的组成部分，而不是类对象的组成部分。

静态成员函数没有this指针。

类中静态成员变量的访问，是需要类名::变量名

int func(){
    static int count = 10;
    return  count--;

}

class Object{
public:
    static int m;
};

int Object::m = 10;

int main(){

    for (int i=0; i<5; i++)
        cout<<func()<<endl;

    cout<<Object::m<<endl;

    return 0;
}

func函数输出10 9 8 7 6 后面输出count的值为10

二、C++的多态

C++的多态(polymorphism)是通过虚函数来实现的，虚函数允许子类重新定义成员函数，而子类重新定义父类的做法称为覆盖(override)，或者称为重写。

虚函数是函数前面加上关键字virtual，

当子类重写父类函数时，如果父类不是虚函数，即没有利用C++的多态性，则利用基类指针(或根据指针的类型)调用相应的函数的时候，将总被限制在基类函数本身，而无法调用到子类中被重写过的函数。这种称为"早绑定"，也就是在编译期间就取定了要调用的函数。

如果父类是虚函数，即函数前面有virtual关键字，调用函数是根据指针指向的内容的类型(对象类型) 来取定调用的方法，即“晚绑定”。虚函数 是在基类中使用关键字 virtual 声明的函数。在派生类中重新定义基类中定义的虚函数时，会告诉编译器不要静态链接到该函数。我们想要的是在程序中任意点可以根据所调用的对象类型来选择调用的函数，这种操作被称为动态链接，或后期绑定。

看代码：

//
// Created by greg on 18-9-8.
//
#include <iostream>
using namespace std;

class A{
public:
    void foo(){
        cout<<"1"<<endl;
    }
    virtual void fun(){
        cout<<"2"<<endl;
    }
};

class B: public A{
public:
    void foo(){      // 重写父类函数，但是父类函数不是虚函数，即静态链接(静态多态) 也就是被“早绑定”  函数调用在程序执行前就准备好了
        cout<<"3"<<endl;
    }

    void fun(){  // 重写父类函数，但是父类函数是虚函数，会告诉编译器不要连接到父类函数，要跟觉调用的对象类型来确定链接的函数，是“晚绑定”
        cout<<"4"<<endl;
    }
};


int main(){
    A a;
    B b;

    A *p = &a;
    p->foo();   // 输出1
    p->fun();   // 输出2

    p = &b;    // p此时的指针类型为 A， 但是它指向的对象为 B
    p->foo();  // 输出1   foo()不是虚函数，根据对象指针类型指向基类
    p->fun();  // 输出4   fun()是虚函数，根据指向的对象类型实现子类的函数  此时看的指针指向的内容而不是指针的类型  体现多态性



    a.foo();   // 1
    a.fun();   // 2

    b.foo();   // 3
    b.fun();   // 4

}