Cacher is the code snippet organizer for pro developers

import subprocess

def runBash(cmd):
    print(f"RUNNING: {cmd}")
    subprocess.check_call(cmd, shell=True)

## 碎片知识
### 堆、栈知识
C++内存布局：
- 栈区：由编译器自动分配释放，存放函数的参数值，局部变量值等，其操作方法类似数据结构中的栈。
- 堆区（heap）：一般由程序员分配释放，与数据结构中的堆毫无关系，分配方式类似于链表。
- 全局/静态区（static）：全局变量和静态变量的存储是放在一起的，在程序编译时分配。
- 文字常量区：存放常量字符串。
- 程序代码区：存放函数体（类的成员函数、全局函数）的二进制代码


C/C++内存分配三种方式 ： 

静态存储区分配，从栈上分配内存和从堆上分配内存。

从静态存储区域分配
- 内存在程序编译的时候就已经分配好，
- 这块内存在程序的整个运行期间都存在。
- 例如全局变量，static变量。
- 静态分配区域的生命期是整个软件运行期，就是说从软件运行开始到软件终止退出。
只有软件终止运行后，这块内存才会被系统回收。

在栈上分配内存
- 在执行函数时，函数内局部变量的存储单元都可以在栈上创建，
- 函数执行结束时这些存储单元自动被释放。
- 栈内存分配运算内置于处理器的指令集中，效率很高，但是分配的内存容量有限。
- 在栈中分配的空间的生命期与这个变量所在的函数和类相关。
如果是函数中定义的局部变量，那么它的生命期就是函数被调用时，如果函数运行结束，
那么这块内存就会被回收。如果是类中的成员变量，则它的生命期与类实例的生命期相同。

从堆上分配内存
- 亦称动态内存分配。程序在运行的时候用malloc或new申请任意多少的内存，
程序员自己负责在何时用free或delete释放内存。动态内存的生存期由我们决定，
- 使用非常灵活，但问题也最多。在堆上分配的内存，生命期是从调用new或者malloc开始，
到调用delete或者free结束。如果不 掉用delete或者free。
则这块空间必须到软件运行结束后才能被系统回收。

## 面向对象
### 类和对象
#### 类的定义
类是创建对象的模板，一个类可以创建多个对象，每个对象都是类类型的一个变量；
创建对象的过程也叫类的实例化。
每个对象都是类的一个具体实例（Instance），拥有类的成员变量和成员函数。

简单的类的定义 eg:
```C++
class Student{
public:
    //成员变量
    char *name;
    int age;
    float score;
    //成员函数
    void say(){
        cout<<name<<"的年龄是"<<age<<"，成绩是"<<score<<endl;
    }
};

Student liLei;  //创建对象，它占用内存空间，可对它的成员变量赋值，也可读取它的成员变量。
Student allStu[100]; //除了创建单个对象，还可以创建对象数组
```
类只是一个模板（Template），编译后不占用内存空间，
所以在定义类时不能对成员变量进行初始化，因为没有地方存储数据。

#### 对象指针
```C++
Student stu;
Student *pStu = &stu; 
//pStu 是一个指针，它指向 Student 类型的数据，也就是通过 Student 创建出来的对象。

Student *pStu = new Student;
//通过 new 创建出来的对象就不一样了，它在堆上分配内存，没有名字，
//只能得到一个指向它的指针，所以必须使用一个指针变量来接收这个指针，
//否则以后再也无法找到这个对象了，更没有办法使用它。

pStu -> name = "小明";
pStu -> age = 15;
pStu -> score = 92.5f;
pStu -> say();
```


### 成员变量和成员函数
可以只在类体中声明成员函数，而将函数定义放在类体外面
```
//函数定义
//:: 域解析符（也称作用域运算符或作用域限定符），连接类名和函数名，指明当前函数属于哪个类。
void Student::say(){
    cout<<name<<"的年龄是"<<age<<"，成绩是"<<score<<endl;
}
```





### 继承与派生
1. 面向对象程序设

module D_FF(
			clk,
			rst,
			q,
			D);
input clk,rst,D;
output q;
reg q;
always @(posedge clk or negedge rst) begin
	if (!rst)
		// reset
		q<=1'b0;
	else
		q<=D;
end
endmodule

from pathlib import Path

for path in Path('src').rglob('*.c'):
    print(path.name)

from sys import platform
if platform == "linux" or platform == "linux2":
    # linux
elif platform == "darwin":
    # OS X
elif platform == "win32":
    # Windows...

# ジェネリックとは

データ型をパラメータ化する仕組み

`<>` の中にデータ型をカンマで区切って指定し、クラスや関数に定義する。

## クラスの場合

```
class Cls<T, U>{
    constructor(private x: T, private y: U){

    }
    public resultX(): T{
        return this.x
    }
    public resultY(): U{
        return this.y
    }
}

let cls = new Cls<string, number>('TypeScript', 999)
let x: string = cls.resultX()
let y: number = cls.resultY()
let z: boolean = cls.resultX() // 型が違うのでエラー
```

## 関数の場合

```
function fnc<T>(x: T): T{
    return x
}

let x: string = fnc<string>('TypeScript')
let y: number = fnc<number>(999)
let z: boolean = fnc<boolean>(true)
```

## 制約の追加

```
interface Hoge{
    hoge(): string
}
class HogeClass implements Hoge{
    public hoge(): string{
        return 'hoge!'
    }
}
// extendsで制約を追加する
class Piyo<T extends Hoge>{
}
// 制約があるパラメータには指定した型自身かそのサブタイプ
let piyo = new Piyo<HogeClass>()
```

function subindex(line, start, replacement) {
    if (start == 0) {
        return replacement substr(line, length(replacement) + 1);
    }
    else {
        return substr(line, 0, start - 1) replacement substr(line, start + length(replacement));
    }
}

// https://loredanacirstea.github.io/es6-design-patterns/
// https://tcorral.github.io/Design-Patterns-in-Javascript/
// https://www.velotio.com/engineering-blog/design-patterns-in-es6

/* SINGELTON
ES6 Modules are singletons. Thus all you have to do is define your object in a module.
Any file you import secret, you are guaranteed to receive the same value. Math.random() is there to tell you if a new value is computed each time.
*/
const phrase = `${Math.random()} shhh`;
export const secret = () => phrase;


/* FACADE
The Facade Pattern provides a unified interface to a set of interfaces in a subsystem. Facade defines a higher-level interface that makes the subsystem easier to use.
*/
import HomeTheaterFacade from './HomeTheaterFacade';
import Amplifier from './elements/Amplifier';
import CdPlayer from './elements/CdPlayer';
import Projector from './elements/Projector';
import TheaterLights from './elements/TheaterLights';
import Screen from './elements/Screen';
im

reregister windows store
powershell -ExecutionPolicy Unrestricted Add-AppxPackage -DisableDevelopmentMode -Register $Env:SystemRoot\WinStore\AppxManifest.xml

reset windows store
wsreset

nuke.toNode('preferences').knob('AutoSaveName').value()

#now check out what happens when you add knobs to it ... they get
#saved to the pref file and persist from session to session ... useful
#way to make persistant user preferences available for your own needs.

# python
import argparse

p = argparse.ArgumentParser()

p.add_argument("-p", type=argparse.FileType("r"))

args = p.parse_args()

#include <iostream>
#include "przyjaciele.h"

using namespace std;

void sedzia(Punkt pkt, Prostokat p)
{
    if ((pkt.x>=p.x)&&(pkt.x<=p.x+p.szerokosc)&&(pkt.y>=p.y)&&(pkt.y<=p.y+p.wysokosc))
    cout<<"punkt "<<pkt.nazwa<<" nalezy do prostokata "<<p.nazwa;
    else cout<<"punkt "<<pkt.nazwa<<" NIE nalezy do prostokata "<<p.nazwa;

}

int main()
{

    Punkt pkt1("A",3,1);
    //pkt1.wczytaj();

    Prostokat p1("Prostokat", 0,0,6,4);
    //p1.wczytaj();

    sedzia(pkt1,p1);

    return 0;
}

some vb code

```javascript
class Point {
  // not needed since constructor has access modifiers
  // private _x: number;
  // _y: number;

  // params can be set as optional (?) since we cannot have multiple constructors.
  constructor(private _x?: number, public _y?: number) {
    // not needed since constructor has access modifiers
    // this._x = _x;
    // this._y = _y;
  }

  draw() {
    console.log('X: ' + this._x);
    console.log('Y: ' + this._y);
  }

  // needed since X is set as private
  get x() {
    return this._x;
  }

  // X is private but can be set after simple validation.
  set x(value) {
    if (value <= 0) {
      throw new Error('value cannot be less than 1');
    }

    this._x = value;
  }
}

let point = new Point(1, 2);

point._y = 4;

let xGetter = point.x; // getter
console.log('X Getter: ' + xGetter);

// point._x = 3; // cannot be accessed, prop set to private.
point.x = 10; // setter on private prop used for simple validation.

point.draw();

// X Getter: 1
// X: 10

//HTML
<p data-toggle="popover" tabindex="0" data-popover-content="#id-11" data-placement="right">text</p>
<div id="id-11" style="display: none">
  <div class="popover-body">
    <strong>Título Lorem Ipsum</strong>
    Lorem ipsum dolor sit amet, consectetur adipiscing elit. Duis libero ipsum,
    <a href="">Saiba mais</a>
  </div>
</div>
                  
// Jquery
$('[data-toggle="popover"]').popover({
  html: true,
  trigger: "focus",
  content: function () {
    var content = $(this).attr("data-popover-content");
    return $(content).children(".popover-body").html();
  },
});
  
//CSS
.popover {
  border-color: #474747;

  &.bs-popover-left > .arrow::before {
    border-left-color: #474747;
  }

  &.bs-popover-left > .arrow::after {
    border-left-color: #474747;
  }

  .popover-body {
    background-color: #474747;
    color: #fff;
    font-size: 14px;
    padding: 12px;
    border-radius: 2px;

    strong {
      font-size: 16px;