Programming on Yuanye Ma's Blog

2019秋招笔试题

yuanye.ma@qq.com (Yuanye Ma) — Thu, 15 Aug 2019 16:01:23 +0800

2019贝壳找房四道笔试题

1. 计算绝对值

题目描述：

给出n个正整数，要求将找出相邻两个数字中差的绝对值最小的一对数字，如果有差的绝对值相同的，则输出最前面的一对数。

输入：

输入包含两行，第一行为n,第二行是用空格分隔的n个正整数。

输出：

输出包含一行两个正整数，要求按照原来的顺序输出。

样例输入：

1
2

9
1 3 4 7 2 6 5 12 32

样例输出：

3 4

code

#include <iostream>

using namespace std;
int main()
{
 int n = 0;
 cin>>n;
 int nums[n];
 for (int i=0; i<n; i++)
 cin>>nums[i];

 int min_dif = abs(nums[1]-nums[0]);
 int l = nums[0];
 int r = nums[1];

 for (int i=1; i<n; i++) {
 int dif = abs(nums[i+1] - nums[i]);
 if(dif < min_dif) {
 l = nums[i];
 r = nums[i+1];
 min_dif = dif;
 }
 }
 cout<<l<<" "<<r<<endl;

 return 0;
}

2. 举重大赛

题目描述：

举重大赛开始了，为了保证公平，要求比赛的双方体重较小值要大于等于较大值的90%，那么对于这N个人最多能进行多少场比赛呢？任意两人之间醉倒进行一场比赛。

输入：

第一行：一个整数N，表示参赛人数（2<=N<=10^5）

第二行： N个正整数表示体重（0<体重<=10^8）

输出：

一个数，表示最多能进行的比赛场数

样例输入：

1
2

5
1 1 1 1 1

样例输出：

code

#include <iostream>

using namespace std;
int main()
{
 int n = 0;
 cin>>n;
 int nums[n];
 for (int i=0; i<n; i++)
 cin>>nums[i];

 int cnt = 0;
 sort(nums, nums+n);

 for (int i=0; i<n; i++) {
 for (int j=i+1; j<n; j++) {
 if(nums[i]>= (double)(9.0/10)*nums[j])
 cnt++;
 else
 break; //已经按照体重进行了排序，所以如果j不满足条件，那么后边的都不满足
 }
 }
 cout<<cnt<<endl;

 return 0;
}

3. 特殊的测试

题目描述：

小C在做一种特殊的服务器负载测试，对于一个请求队列中的请求，每一个请求都有一个负荷值，为了保证服务器稳定，请求队列中的请求负荷必须按照先递增后递减的规律（仅递增，仅递减也可以），比如[1,2,8,4,3]和[1,3,5]都是满足要求的。还有一些不满足的，比如[1,2,2,1]和[2，1，2]。现在给你一个请求队列，你可以对请求的负荷值进行增加，要求调整完的序列满足要求。

输入：

第一行是N（1<=N<=5000）,代表请求队列中的请求数量。

第二行有N个整数Ai, Ai是第i个请求的负荷值。

输出：

输出这个最小增加总和。

样例输入：

1
2

5
1 4 3 2 5

样例输出：

样例说明：

1 5 3+2 2+4 5 一共增加了2+4=6。

code

#include <iostream>
#include <vector>

using namespace std;
int main()
{
 int n = 0;
 cin>>n;
 int nums[n];
 for (int i=0; i<n; i++)
 cin>>nums[i];

 vector<int> back(nums, nums+n);

 if (n<2) {
 return 0;
 } else if (n==2) {
 if(nums[0] == nums[1])
 return 1;
 else
 return 0;
 } else {
 int i = 0;
 while (i<n-1 && nums[i]<nums[i+1])
 i++;
 int j = n-1;
 while (j>0 && nums[j]<nums[j-1])
 j--;
 while (i<j) {
 if (nums[i] < nums[j]) {
 if (nums[i] > nums[i+1])
 nums[i+1] = nums[i]+1;
 i++;
 } else {
 if (nums[j] > nums[j-1])
 nums[j-1] = nums[j]+1;
 j--;
 }
 }
 }
 int sum = 0;
 for (int i=0; i<n; i++) {
 sum+=(nums[i]-back[i]);
 }
 cout<<sum<<endl;

 return 0;
}

4. 最长上升子序列

leetcode的第300道题目

题目描述：

给定一个无序的整数数组，找到其中最长上升子序列的长度。

输入: [10,9,2,5,3,7,101,18]
输出: 4
解释: 最长的上升子序列是 [2,3,7,101]，它的长度是 4。

code

#include <iostream>
#include <vector>

using namespace std;
int main()
{
 int n = 0;
 cin>>n;
 int nums[n];
 for (int i=0; i<n; i++)
 cin>>nums[i];
 int maxx = 0;

 int dp[n];
 for (int i=0; i<n; i++) {
 dp[i] = 1;
 for (int j=0; j<i; j++) {
 if (nums[j] < nums[i])
 dp[i] = max(dp[i], dp[j]+1);
 }
 if (dp[i] > maxx)
 maxx = dp[i];
 }
 cout<<maxx<<endl;

 return 0;
}

图森笔试题

1. 求卷积

code

#include <iostream>
#include <vector>

using namespace std;

int A[505][505];
int B[3][3];

int main()
{
 int n, m;
 cin>>n>>m;
 for (int i=0; i<n; i++) {
 for (int j=0; j<m; j++) {
 cin>>A[i][j];
 }
 }

 for (int i=0; i<3; i++) {
 for (int j=0; j<3; j++) {
 cin>>B[i][j];
 }
 }

 vector<vector<int> > C(n-2, vector<int>(m-2));

 for (int i=0; i<(n-2); i++) {
 for (int j=0; j<(m-2); j++) {
 int sum = 0;
 for (int k=0; k<3; k++){
 for (int l=0; l<3; l++) {
 sum += A[i+k][j+l] * B[k][l];
 }
 }
 C[i][j] = sum;
 cout<<C[i][j]<<" ";
 }
 cout<<endl;
 }

 return 0;
}

2. 迷宫求最短路径

code

#include <iostream>
#include <queue>

using namespace std;

const int MAX_N = 1005;
const int MAX_M = 1005;
const int INF = 0x3f3f3f3f;
typedef pair<int, int> P;

char maze[MAX_N][MAX_M + 1];
int N, M;
int sx, sy; //起点的位置
int gx, gy; //终点的位置

int d[MAX_N][MAX_M];//储存起点到某一点的距离
int dx[4] = { 1,0,-1,0 }, dy[4] = { 0,1,0,-1 }; //表明每次x和y方向的位移

void bfs()
{
 queue<P> que;
 for (int i = 0; i < N; i++)
 for (int j = 0; j < M; j++)
 d[i][j] = INF; //初始化所有点的距离为INF

 que.push(P(sx, sy));

 d[sx][sy] = 0; //从起点出发将距离设为0，并放入队列首端

 while (que.size()) //题目保证有路到终点，所以不用担心死循环
 {
 P p = que.front();
 que.pop();//弹出队首元素
 int i;
 for (i = 0; i < 4; i++)
 {
 int nx = p.first + dx[i];
 int ny = p.second + dy[i];//移动后的坐标
 //判断可移动且没到过
 if (0 <= nx && nx < N
 && 0 <= ny && ny < M
 && maze[nx][ny] != '#'
 && d[nx][ny] == INF)//之前到过的话不用考虑，因为距离在队列中递增，肯定不会获得更好的解
 {
 que.push(P(nx, ny)); //可以移动则设定距离为之前加一，放入队列
 d[nx][ny] = d[p.first][p.second] + 1;
 if(nx==gx && ny==gy)
 break;

 }
 }
 if(i!=4)
 break;
 }

}

int main()
{
 cin>>N>>M;

 for (int i = 0; i < N; i++)
 for (int j = 0; j < M; j++)
 {
 cin>>maze[i][j];
 if (maze[i][j] == 'S')
 {
 sx = i; sy = j;
 }
 if (maze[i][j] == 'E')
 {
 gx = i; gy = j;
 }
 }
 bfs();
 cout<<d[gx][gy]<<endl;

 return 0;
}

3. 我也不知道是什么题

code

#include <iostream>
#include <vector>
#include <string>

using namespace std;

string toStr(int x)
{
 string ans;
 while(x) {
 ans.push_back(x%10+'0');
 x /= 10;
 }
 return string(ans.rbegin(), ans.rend());
}

vector<char> tok(int x, int k)
{
 string tt = toStr(x);
 int len_t = tt.length();
 vector<char> str_t;

 int kk = k/len_t;
 if (kk%len_t || kk==0)
 kk+=1;

 for (int i=kk-1;i>=0; i--) {
 for (int j=i; j<len_t+i; j++) {
 str_t.push_back( tt[j%len_t] );
 }
 }
 return str_t;
}

string winer(int t, int s, int k)
{
 vector<char> v_t = tok(t, k);
 vector<char> s_t = tok(s, k);
 int l_v_t = v_t.size()-k;
 int l_v_s = s_t.size()-k;

 int i;
 for (i=0; i<k; i++) {
 if (v_t[l_v_t+i] > s_t[l_v_s+i]) {
 return "Tu";
 } else if (v_t[l_v_t+i] < s_t[l_v_s+i]) {
 return "Simple";
 }
 }
 if (i==k)
 return "Draw";
}


int main()
{
 int n;
 cin>>n;
 for (int i=0; i<n; i++) {
 int t, s, k;
 cin>>t>>s>>k;
 cout<<winer(t, s, k)<<endl;
 }
 return 0;
}

小米

1. 完全背包问题

n件商品，每件商品的价格固定，数量不限，固定的钱数，求最少拿走的商品数量。

2. 给定一个字符串表示的二叉树，输出中序遍历序列

输入样例：1(2(3,4(,5)),6(7,))

输出样例：3245176

string solution(string)
{
 string res;
 int len = input.length();
 if (len == 0)
 return res;

 stack<char> st;
 for (int i=0; i<len; i++) {
 if (input[i] == '(' || input[i] ==')')
 continue;
 if (input[i]>='0' && input[i]<='9')
 st.push(input[i]);

 if (input[i] == ',') {
 if (st.empty())
 continue;
 res.push_back(st.top());
 st.pop();

 if ((input[i-1]>='0' && input[i-1]<='9') || (input[i-1]==')')) {
 if (st.empty())
 continue;
 res.push_back(st.top());
 st.pop();
 }
 }
 }
 while (!st.empty()) {
 res.push_back(st.top);
 st.pop();
 }
 return res;
}

华为

1. 计算数轴上关系匹配的点

#include <iostream>
#include <string>
#include <vector>

using namespace std;

int str2int(string str)
{
 int res = 0;
 for (auto it=str.begin(); it!=str.end(); it++) {
 if (*it > '0' && *it < '9') {
 int x = *it-'0';
 res = res*10+x;
 }
 }
 return res;
}

string int2str(int n)
{
 string res;
 while (n) {
 int a = n%10;
 res.push_back(a+'0');
 n /= 10;
 }
 return string(res.rbegin(), res.rend());
}


string check(vector<int> A, vector<int> B, int R)
{
 string res;
 int len_a = A.size();
 int len_b = B.size();
 for (int i=0; i<len_a; i++)
 {
 if (A[i] > B[len_b-1])
 break;

 bool flag = false;
 for (int j=0; j<len_b; j++) {
 if (A[i] <= B[j]) {
 if (B[j]-A[i] <= R) {
 res += "(" +int2str(A[i]) + "," + int2str(B[j]) + ")";
 flag = true;
 }
 }
 }
 if (!flag) {
 int j = len_b-1;
 while(B[j]>=A[i])
 j--;
 res += "(" + int2str(A[i]) + "," + int2str(B[j+1]) +")";
 }
 }
 return res;
}

vector<int> str2vec(string str)
{
 string tmp;
 vector<int> vec;
 for (auto it=str.begin(); it!=str.end(); it++) {
 if (*it >= '0' && *it <= '9') {
 tmp.push_back(*it);
 } else if (*it == ',' || *it == '}') {
 vec.push_back(str2int(tmp));
 tmp = "";
 }
 }
 return vec;
}

int main()
{
 string s;
 cin>>s;
 int pos = s.find('R');
 string R = s.substr(pos+2);
 int r = str2int(R);
 s = s.substr(0, pos-1);

 pos = s.find("B");
 string str_b = s.substr(pos+3);
 vector<int> B = str2vec(str_b);

 s = s.substr(0, pos-1);

 string str_a = s.substr(3);
 vector<int> A = str2vec(str_a);


 cout<<check(A, B, r);
 return 0;
}

2. 翻转字符串

#include <iostream>
#include <string>
#include <vector>

using namespace std;

#define VALID(it) ((*(it)>='0' && *(it)<='9') || (*(it)>='a'&&*(it)<='z') || (*(it)>='A'&& *(it)<='Z') )

int main()
{
 string str;
 getline(cin, str);

 string n_str;
 for (auto it=str.begin(); it!=str.end(); it++) {
 if ( VALID(it) ) {
 n_str.push_back(*it);
 } else {
 if (*it == '-') {
 if (VALID((it+1)) && VALID((it-1)) )
 n_str.push_back(*it);
 }
 auto it = n_str.end();
 if (*(it-1) != ' ')
 n_str.push_back(' ');
 }
 }

 int pos;
 while((pos=n_str.rfind(' ')) != string::npos){
 string ss = n_str.substr(pos+1);
 cout<<ss<<" ";
 n_str = n_str.substr(0, pos);
 }
 cout<<n_str<<endl;

 return 0;
}

另一种方法

 1 #include <stdio.h>
 2 #include <string.h>
 3
 4 static char buf[] = "I am an 20 ye-ars out--standing @ * -stu- dent";
 5
 6 int is_valid(char ch)
 7 {
 8 if (((ch>='a') && (ch<='z'))
 9 || ((ch>='A') && (ch<='Z'))
 10 || ((ch >= '0') && (ch <= '9'))) {
 11 return 1;
 12 }
 13 else {
 14 return 0;
 15 }
 16 }
 17
 18 int main(void)
 19 {
 20 char *pos = NULL;
 21 int size = 0;
 22 int i = 0;
 23
 24 size = strlen(buf) + 1;
 25 printf("size: %d\n", size);
 26
 27 for (pos = buf + size - 2; pos != buf; pos--) {
 28 if (!is_valid(*pos)) {
 29 if ((*pos == '-')) {
 30 if ((is_valid(*(pos-1))) && (is_valid(*(pos+1)))) {
 31 continue;
 32 }
 33 else {
 34 *pos = 0;
 35 }
 36 }
 37 if (*(pos + 1) != '\0') {
 38 printf("%s ", pos + 1);
 39 }
 40 *pos = 0;
 41 }
 42 }
 43 printf("%s\n", buf);
 44
 45 return 0;
 46 }

3. 修改机票信息

#include <iostream>
#include <string>
#include <vector>
#include <cstring>
#include <algorithm>

using namespace std;

struct INFO{
 string hbh;
 string zwh;
 string name;
 bool rewrite;

 INFO(string num_hb, string num_zw, string na)
 {
 this->hbh = num_hb;
 this->zwh = num_zw;
 this->name = na;
 this->rewrite = false;
 }
};

bool cmp(const INFO & a, const INFO & b)
{
 if (a.hbh == b.hbh) {
 return a.zwh<b.zwh;
 } else {
 return a.hbh<b.hbh;
 }

}

int main()
{
 int n, m;
 cin>>n;
 vector<INFO> info;

 for (int i=0; i<n; i++) {
 string hbh, zwh, name;
 cin>>hbh>>zwh>>name;
 INFO tmp(hbh, zwh, name);
 info.push_back(tmp);
 }

 cin>>m;
 for (int i=0; i<m; i++) {
 string ohb, ozw, nhb, nzw;
 cin>>ohb>>ozw>>nhb>>nzw;
 for (int j=0; j<n; j++) {
 if ((ohb == info[j].hbh) && (ozw == info[j].zwh) && !(info[j].rewrite)) {
 info[j].hbh = nhb;
 info[j].zwh = nzw;
 info[j].rewrite = true;
 }
 }
 }

 sort(info.begin(), info.end(), cmp);
 for (int i=0; i<n; i++) {
 cout<<info[i].hbh<<","<<info[i].zwh<<","<<info[i].name<<endl;
 }

 return 0;
}

总结

华为的题，总体感觉不难，和刷LeetCode的感觉是不一样的，leetcode注重算法。而华为的题感觉更加注重用代码实现逻辑功能。输入处理起来异常麻烦。

第一题没有A掉，很明显代码中的条件处理的也不够，但是过了百分之八十，我同学他们没有考虑数字是两位或者多位的情况也过了百分之八十，不知道怎么回事。

第二题A掉了。

第三题，没时间写完，后来写的没有处理机票重复的情况。

vivo

1. 2. 报数

N个人站成一个圈，从1开始报数到M的整数倍时出去一个人，问出去的人的序列。

#include <stdio.h>
#include <stdlib.h>
#include <iostream>
#include <string.h>

using namespace std;

/**
 * Welcome to vivo !
 */

typedef struct _node
{
 int num;
 struct _node * next;
}node;

void solution(int N, int M)
{
 // TODO Write your code here
 node * head = NULL;
 node * tail = NULL;

 for (int i=1; i<=N; i++) {
 node * p = new node;
 p->num = i;
 p->next = NULL;
 if (head == NULL) {
 head = p;
 tail = p;
 } else {
 tail->next = p;
 tail = p;
 tail->next = head;
 }
 }
 node * q = head;
 int count = 1;
 while (q!=NULL && q!=q->next) {
 if (count % M == 0) {
 cout<<q->num<<" ";
 node * qq = q->next;
 q->num = qq->num;
 q->next = qq->next;
 delete qq;
 } else {
 q=q->next;
 }
 count++;
 }
 if (q!=NULL)
 cout<<q->num<<endl;
}

int main()
{
 int N;
 int M;

 string str("");
 getline(cin, str);

 char *p;
 const char* strs = str.c_str();

 p = strtok((char *)strs, " ");
 N = atoi(p);

 p = strtok(NULL, " ");
 M = atoi(p);

 solution(N, M);

 return 0;
}

3. 天平问题

类似与这道题

C++继承和多态

yuanye.ma@qq.com (Yuanye Ma) — Tue, 06 Aug 2019 16:01:23 +0800

C++继承和多态

继承

语法

class 子类名/派生类名 ： 继承方式 父类名/基类名
{

};

继承方式

public : 公共权限，类内/外都可以直接访问；

protected : 保护权限，类内部以及子类内部可以直接访问，类外不能访问；

private ：私有权限，只能在类内部访问；

class Base {
public:
 int m_A;
protected:
 int m_B;
private:
 int m_C;
};

//公共继承
class Son : public Base {
 // 父类中public修饰的属性，在子类中仍然是public的
 // 父类中protected修饰的属性，在子类中仍然是protected的
 // 父类中private修饰的属性，在子类中不可见
};

//保护继承
class Son : protected Base {
 // 父类中public修饰的属性，在子类中变为protected的
 // 父类中protected修饰的属性，在子类中仍然是protected的
 // 父类中private修饰的属性，在子类中不可见
};

//私有继承
class Son : private Base {
 // 父类中public修饰的属性，在子类中变为private的
 // 父类中protected修饰的属性，在子类中变为private的
 // 父类中private修饰的属性，在子类中不可见
};

继承中的构造和析构

class Base
{
public:
Base(int a)
{
m_A = a;
}
int m_A;
}
class Son: public Base
{
public:
Son(int a):Base(a) //在初始化列表中调用父类的构造函数
{
}
}

先构造父类对象，然后创建子类对象。析构顺序和构造相反。

但是子类不会继承父类的构造函数和析构函数。

多继承

class Base1
{
 Base1()
 {
 m_A = 10;
 }
 int m_A;
};

class Base2
{
 Base2()
 {
 m_B = 100; // 假如此变量也是m_A 在 Son s; s.m_A=10时会出现二义性。
 }
 int m_B;
};

class Son: public Base1, public Base2
{
 int m_C;
 int m_D;
}

cout<<sizeof(Son)<<endl; // 32位机器 输出 16

菱形继承

class Animal
{
public:
 int m_Age;
}

class Sheep: public Animal
{

}
class Tuo: public Animal
{

}
class SheepTuo: public Sheep, public Tuo
{

}

SheepTuo st;
st.Sheep::m_Age = 10
st.Tuo::m_Age = 20
// 相互不影响，但是会造成冗余甚至二义性
cout<<st.m_Age

菱形继承的解决方案，利用虚继承

class Animal
{
public:
 int m_Age;
}

// 虚基类
class Sheep: public Animal
{

}
// 虚基类
class Tuo: virtual public Animal
{

}
class SheepTuo: public Sheep, public Tuo
{

}

SheepTuo st;
st.Sheep::m_Age = 10
st.Tuo::m_Age = 20
cout<<st.m_Age<<endl; //输出20，上边两句修改的是同一块内存

//SheepTuo内部有一个vbptr : virtual base pointer(虚基类指针)
 +---
 |+---（base class Sheep）
0|| (vbptr)
 |+---
 |+---（base class Tuo）
4|| (vbptr)
 |+---
 +---
 +---（virtual base Animal）
8| m_Age
 +---

SheepTuo::$vbtable@Sheep@:
0 | 0
1 | 8 (SheepTuod(Sheep+0)Animal)
SheepTuo::$vbtable@Tuo@:
0 | 0
1 | 4 (SheepTuod(Tuo+0)Animal)

继承中的对象模型

class Base{
public:
 int m_A;
protected:
 int m_B;
private:
 int m_C;
};

class Son:public Base {
public:
 int m_D;
};

void test01()
{
 cout<<"sizeof(int)"<<sizeof(int)<<endl; // 在32位机的情况下输出是4
 cout<<"sizeof(Son)"<<sizeof(Son)<<endl; // 输出16
 // 父类中private的内容，在子类中是访问不到的，但是也被继承下来了，被编译器给隐藏掉了

}

Vs2013 开发人员命令提示工具可以查看对象模型

先cd到cpp文件所造的目录

cl /d1 reportSingleClassLayout类名 cpp文件名

继承中的同名成员处理

class Base
{
public:
 Base()
 {
 m_A = 100;
 }
 void func()
 {
 cout<<"Base 中调用了func"<<endl;
 }
 int m_A;
};

class Son : public Base
{
public:
 Son()
 {
 m_A = 200;
 }
 int m_A;
};

Son s;
cout<<s.m_A<<endl; // 输出 200
// 从父类中获取m_A
cout<<s.Base::m_A<<endl; // 输出 100

s.func(); // 输出 Base 中调用了func
// 如果在子类中重新定义了和父类中某一函数，那么将会隐藏掉父类中所有的同名成员函数（包括重载函数）

防止继承的方式

`1`	`class NoDrived final{...} // 类名后加final说明此类不能被继承`

多态

静态联编：程序在编译的时候确定，函数重载就是静态联编形式

动态联编：程序在执行时确定

class Animal
{
 speak()
 {
 cout<<"动物在说话"<<endl;
 }
};

class Cat:public Animal
{
 speak()
 {
 cout<<"喵喵喵"<<endl;
 }
};

//调用doSpeak，speak函数的地址在编译的时候就已经绑定好了，绑定为Animal::speak()
void doSpeak(Animal & animal)
{
 animal.speak();
}

int main()
{
 Cat cat;
 doSpeak(cat); // 输出： ”动物在说话“
}
// 如果想输出 "喵喵喵"，就不能静态联编，需要在运行时确定函数地址
// 动态联编， 将Animal的Speak改写成虚函数
class Animal
{
 virtual speak() // 父类的引用或者指针指向子类的成员函数
 {
 cout<<"动物在说话"<<endl;
 }
};

虚函数表

class Animal
{
 speak()
 {
 cout<<"动物在说话"<<endl;
 }
};
sizeof(Animal) = 1

 class Animal
{
 virtual speak()
 {
 cout<<"动物在说话"<<endl;
 }
};
sizeof(Animal) = 4

vfptr: virtual function pointer 虚函数表指针


Animal * animal = new Cat;
animal->speak(); //输出 ”喵喵喵“

多态原理解析

当父类中有了虚函数后，内部结构发生了改变

内部多了一个vfptr,指向虚函数表。

父类中结构vfptr &Animal::speak

构造函数中，会将虚函数表指针，指向自己的虚函数表

如果发生了重写，会替换掉虚函数表中原有的speak 改为&Cat::speak

虚函数

non-virtual函数：你不希望derived class重新定义（overrude，覆写，虚函数被重新定义）它

virtual函数 : 你希望derived class重新定义（overrude）它，它已经有了一个默认的定义，可以不override。

pure-virtual函数：你希望derived class重新定义（overrude）它，必须要override，没有默认定义。

任何构造函数外的非静态函数都可以是虚函数。

class Shape {
public:
 virtual void draw() const = 0; // 纯虚函数
 virtual void error(); //虚函数
 int objectlD() const; //非虚函数
};
class Rectabgle: public Shape{...};
class Ellipse: public Shape{...};

一道题

64位电脑运行以下c++代码结果输出什么？
class A{
 char a[2];
public:
 virtual void aa(){}
};

class B:public virtual A{
 char b[2];
 char a[2];
public:
 virtual void bb(){};
 virtual void aa(){};
};

class C:public virtual B{
 char a[2];
 char b[2];
 char c[2];
public:
 virtual void cc(){};
 virtual void aa(){};
 virtual void bb(){};
};

int main()
{
 cout<<sizeof(A)<<endl;
 cout<<sizeof(B)<<endl;
 cout<<sizeof(C)<<endl;
}
此题目应该输出：
16
32
48

64位机器所以指针占8个字节的内存。

对于类A：a占两个字节的内存，八字节内存对齐，后边的虚函数表是个指针因此也占8个字节的内存，因此sizeof(A) = 16B;

由于B继承自A，因此B内又完全包含一个A，a+b=4个字节仍然不满8个字节，仍然需要填充4个字节来保持内存对齐，因此sizeof(B) = 16+16 = 32B。

同理sizeof(C) = 48B。

tensorboardX的用法

yuanye.ma@qq.com (Yuanye Ma) — Sat, 20 Jul 2019 16:01:23 +0800

pytorch+tensorboardX

简单总结一下tensorboardX的用法。

import numpy as np
from tensorboardX import SummaryWriter

write = SummaryWriter()

for epoch in range(100):
 write.add_scalar('scale/test', np.random.rand(), epoch)
 write.add_scalars('scale/scales_test', {'xsinx':epoch*np.sin(epoch), 'xcosx' : epoch*np.cos(epoch)}, epoch)

write.close()

在终端中运行上边代码:python ./tensorboard_scales.py，查看代码目录下多了一个runs的目录，里边保存的就是代码运行时的数据。

再使用tensorboard --logdir runs,在浏览器地址栏输入ip_address:6006就能看到图像。

此时再次运行代码，再查看目录结构，会发现又多了一些目录，这是因为tensorboard会保存几个历史版本。这个功能很好用，可以通过点击左下角的复选框勾选要对比的曲线，进而对比模型的性能。

试试graph

import torch
import torch.nn as nn
import torch.nn.functional as F
from tensorboardX import SummaryWriter


class Net1(nn.Module):
 def __init__(self):
 super(Net1, self).__init__()
 self.conv1 = nn.Conv2d(1, 10, kernel_size=5)
 self.conv2 = nn.Conv2d(10, 20, kernel_size=5)
 self.conv2_drop = nn.Dropout2d()
 self.fc1 = nn.Linear(320, 50)
 self.fc2 = nn.Linear(50, 10)
 self.bn = nn.BatchNorm2d(20)

 def forward(self, x):
 x = F.max_pool2d(self.conv1(x), 2)
 x = F.relu(x) + F.relu(-x)
 x = F.relu(F.max_pool2d(self.conv2_drop(self.conv2(x)), 2))
 x = self.bn(x)
 x = x.view(-1, 320)
 x = F.relu(self.fc1(x))
 x = F.dropout(x, training=self.training)
 x = self.fc2(x)
 x = F.softmax(x, dim=1)
 return x


dummy_input = torch.rand(13, 1, 28, 28)

model = Net1()
with SummaryWriter(comment='Net1') as w:
 w.add_graph(model, (dummy_input,))

在运行的时候报错了。

上网搜索了一番说是pytorch版本的问题，为了跑写好的强化学习的代码，我用的是比较老的0.4.0版本的，回头有机会测一下pytorch 1.0+的看可不可以用。

总结一下TensorboardX的用法

声明一个SummaryWriter()对象，log_dir参数能指定log文件保存的路径。
然后使用add_xxx()函数向log中添加内容，xxx可以是scalar, image, figure, histogram, audio, text, graph, onnx_graph, embedding, pr_curve, mesh, hyper-parameters and video，详情参见或者tensorboardX。
关闭SummaryWriter()对象
使用tensorboard --logdir命令启动tensorboard
在浏览器里查看输出。

TensorFlow+TensorBoard

参考这篇blog

总结一下使用的步骤

建立一个计算图（Graph）
确定要在Graph中的哪些节点放置summary operations（即要在tensorboard中观察哪些数据）
1. tf.summary.scalar - 记录标量
2. tf.summary.histogram - 记录数据的直方图
3. tf.summary.image - 记录图片
4. tf.summary.audio - 记录音频
5. tf.summary.graph - 记录计算图结构
6. tf.summary.distribution - 记录数据分布
7. tf.summary.embeddings - 记录嵌入向量
8. tf.summary.text - 记录文本
使用tf.summary.merge_all将所有summary operations合并为一个operation
运行3中合并之后的operation:summary = sess.run(all_summary)
声明一个FileWriter对象：writer = tf.summary.FileWriter("./train", graph) #如果有graph参数，可以在tensorboard中查看graph的结构。
使用tf.summary.FileWriter将数据写入本地磁盘: writer.add_summary(summary, steps)
运行程序后，使用tensorboard --logdir=logdir启动tensorboard,然后在浏览器中查看。

参考代码

import tensorflow as tf

from tensorflow.examples.tutorials.mnist import input_data

max_steps = 1000 # 最大迭代次数
learning_rate = 0.001 # 学习率
dropout = 0.9 # dropout时随机保留神经元的比例

data_dir = './' # 样本数据存储的路径
log_dir = './' # 输出日志保存的路径

mnist = input_data.read_data_sets(data_dir, one_hot=True)

sess = tf.InteractiveSession()

with tf.name_scope('input'):
 x = tf.placeholder(tf.float32, [None, 784], name='x-input')
 y_ = tf.placeholder(tf.float32, [None, 10], name='y-input')

with tf.name_scope('input_reshape'):
 image_shaped_input = tf.reshape(x, [-1, 28, 28, 1])
 tf.summary.image('input', image_shaped_input, 10)

def weight_variable(shape):
 """Create a weight variable with appropriate initialization."""
 initial = tf.truncated_normal(shape, stddev=0.1)
 return tf.Variable(initial)

def bias_variable(shape):
 """Create a bias variable with appropriate initialization."""
 initial = tf.constant(0.1, shape=shape)
 return tf.Variable(initial)

def variable_summaries(var):
 """Attach a lot of summaries to a Tensor (for TensorBoard visualization)."""
 with tf.name_scope('summaries'):
 # 计算参数的均值，并使用tf.summary.scaler记录
 mean = tf.reduce_mean(var)
 tf.summary.scalar('mean', mean)

 # 计算参数的标准差
 with tf.name_scope('stddev'):
 stddev = tf.sqrt(tf.reduce_mean(tf.square(var - mean)))
 # 使用tf.summary.scaler记录记录下标准差，最大值，最小值
 tf.summary.scalar('stddev', stddev)
 tf.summary.scalar('max', tf.reduce_max(var))
 tf.summary.scalar('min', tf.reduce_min(var))
 # 用直方图记录参数的分布
 tf.summary.histogram('histogram', var)


def nn_layer(input_tensor, input_dim, output_dim, layer_name, act=tf.nn.relu):
 """Reusable code for making a simple neural net layer.
 It does a matrix multiply, bias add, and then uses relu to nonlinearize.
 It also sets up name scoping so that the resultant graph is easy to read,
 and adds a number of summary ops.
 """
 # 设置命名空间
 with tf.name_scope(layer_name):
 # 调用之前的方法初始化权重w，并且调用参数信息的记录方法，记录w的信息
 with tf.name_scope('weights'):
 weights = weight_variable([input_dim, output_dim])
 variable_summaries(weights)
 # 调用之前的方法初始化权重b，并且调用参数信息的记录方法，记录b的信息
 with tf.name_scope('biases'):
 biases = bias_variable([output_dim])
 variable_summaries(biases)
 # 执行wx+b的线性计算，并且用直方图记录下来
 with tf.name_scope('linear_compute'):
 preactivate = tf.matmul(input_tensor, weights) + biases
 tf.summary.histogram('linear', preactivate)
 # 将线性输出经过激励函数，并将输出也用直方图记录下来
 activations = act(preactivate, name='activation')
 tf.summary.histogram('activations', activations)

 # 返回激励层的最终输出
 return activations


hidden1 = nn_layer(x, 784, 500, 'layer1')

with tf.name_scope('dropout'):
 keep_prob = tf.placeholder(tf.float32)
 tf.summary.scalar('dropout_keep_probability', keep_prob)
 dropped = tf.nn.dropout(hidden1, keep_prob)

y = nn_layer(dropped, 500, 10, 'layer2', act=tf.identity)

with tf.name_scope('loss'):
 # 计算交叉熵损失（每个样本都会有一个损失）
 diff = tf.nn.softmax_cross_entropy_with_logits(labels=y_, logits=y)
 with tf.name_scope('total'):
 # 计算所有样本交叉熵损失的均值
 cross_entropy = tf.reduce_mean(diff)

tf.summary.scalar('loss', cross_entropy)

with tf.name_scope('train'):
 train_step = tf.train.AdamOptimizer(learning_rate).minimize(
 cross_entropy)

with tf.name_scope('accuracy'):
 with tf.name_scope('correct_prediction'):
 # 分别将预测和真实的标签中取出最大值的索引，弱相同则返回1(true),不同则返回0(false)
 correct_prediction = tf.equal(tf.argmax(y, 1), tf.argmax(y_, 1))
 with tf.name_scope('accuracy'):
 # 求均值即为准确率
 accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))
tf.summary.scalar('accuracy', accuracy)

# summaries合并
merged = tf.summary.merge_all()
# 写到指定的磁盘路径中
train_writer = tf.summary.FileWriter(log_dir + '/train', sess.graph)
test_writer = tf.summary.FileWriter(log_dir + '/test')

# 运行初始化所有变量
tf.global_variables_initializer().run()

def feed_dict(train):
 """Make a TensorFlow feed_dict: maps data onto Tensor placeholders."""
 if train:
 xs, ys = mnist.train.next_batch(100)
 k = dropout
 else:
 xs, ys = mnist.test.images, mnist.test.labels
 k = 1.0
 return {x: xs, y_: ys, keep_prob: k}


for i in range(max_steps):
 if i % 10 == 0: # 记录测试集的summary与accuracy
 summary, acc = sess.run([merged, accuracy], feed_dict=feed_dict(False))
 test_writer.add_summary(summary, i)
 print('Accuracy at step %s: %s' % (i, acc))
 else: # 记录训练集的summary
 if i % 100 == 99: # Record execution stats
 run_options = tf.RunOptions(trace_level=tf.RunOptions.FULL_TRACE)
 run_metadata = tf.RunMetadata()
 summary, _ = sess.run([merged, train_step],
 feed_dict=feed_dict(True),
 options=run_options,
 run_metadata=run_metadata)
 train_writer.add_run_metadata(run_metadata, 'step%03d' % i)
 train_writer.add_summary(summary, i)
 print('Adding run metadata for', i)
 else: # Record a summary
 summary, _ = sess.run([merged, train_step], feed_dict=feed_dict(True))
 train_writer.add_summary(summary, i)


train_writer.close()
test_writer.close()

C++ Primer Plus笔记

yuanye.ma@qq.com (Yuanye Ma) — Mon, 15 Apr 2019 16:01:23 +0800

C++ Primer Plus笔记

第十章：对象和类

类和结构(class和struct)的区别：结构的默认访问类型是public，而类的默认访问类型是private。

所创建的每个新对象都有自己的存储空间，用于存储其内部变量和类成员；但同一个类的所有对象共享同一组类方法，即每种方法只有一个副本。

内联函数

内联函数是C++为提高程序运行速度所做的改进，常规函数和内联函数之间的主要区别不在于编写方式，而是编译方式。常规函数调用的时候需要执行函数调用操作(参数入栈，设置返回点，跳转到函数入口等)，而内联函数在编译的时候直接在调用处展开函数代码，在执行的时候并没有进行函数调用。

因此，多次调用同一个内联函数的时候，编译器会在内联函数被调用处展开多个函数实例，和常规函数调用相比占用更多的内存空间。

内联函数适用于函数调用开销比函数执行开销还要大的场合，内联函数不能递归。

与宏的区别：宏只是字符串替换，没有函数传递的性质，内联函数也是函数，可以传递参数。

其定义位于类声明中的函数都将自动成为内联函数(下边的set_tot函数)

#ifndef STOCK_H
#define STOCK_H
#include <string>
class Stock
{
 private:
 std::string company;
 long shares;
 double total_val;
 double share_val;
 void set_tot() {total_cal = shares * share_val;}
 public:
 void acquire(const std::string & co, long n, double pr);
}
#endif

也可以在类声明外定义内联函数

inline void Stock::set_tot()
{
 total_val = shares*share_val;
}

构造函数

C++提供了两种使用构造函数来初始化对象的形式，第一种是显式的调用构造函数：

1
2

Stock food = Stock("World Cabbage", 250, 1,25); //根据编译器编译规则不同，可能会创建临时对象
stock1 = Stock("Nifty Foods", 10, 50.0); //赋值，总是会在赋值前创建一个临时对象，效率更低

另外一种是隐式的调用：

`1`	`Stock garment("Furry Mason", 50, 2.5);`

此外还有默认构造函数和拷贝构造函数

默认构造函数：未提供显式初始值时，下边是使用默认构造函数的三种形式。

1
2
3

Stock fluffy_the_cat;
Stock first = Stock();
Stock * prelief = new Stock;

当且仅当没有定义任何构造函数的时候，编译器才会提供默认构造函数；为类定义了构造函数后就必须为它提供默认构造函数。如果定义了非默认参数的构造函数，而没用定义默认构造函数则上边的声明会报错。

默认构造函数可以通过两种方式定义：直接定义一个不接收参数的构造函数；定义提供默认参数的构造函数。

Stock::Stock()
{
 company = "no name";
 shares = 0;
 share_val = 0.0;
 total_val = 0.0;
}
或者
Stock::Stock(const string & co = "Error", int n = 0, double pr = 0.0);
C++11还可以通过参数列表的形式定义

拷贝构造：也叫复制构造，用于将一个对象复制到新创建的对象中。下边四种方式都是拷贝构造。每当程序生成了对象副本时，编译器都将使用拷贝构造函数。编译器生成临时对象时，也将使用拷贝构造函数。

StringBad ditto(motto);
StringBad metoo = metoo;
StringBad also = StringBad(motto);
StringBad * pStringBad = new StringBad(const StringBad &);

const成员函数

1
2

const Stock land = Stock("Kludge");
land.show();

第二行的land.show()编译的时候会出错，因为show()方法可能会更改land对象的属性，而land对象又被const所修饰。正确的做法是，在声明和定义show()方法的时候将其定义为const成员函数，像下边这样。

void show() const;
void Stock::show() const
{
 ....
}

对象数组

const int STKS = 10;
Stock stocks[STKS] = {
 Stock("aefaf", 12,5, 20),
 Stock(),
 Stock("dsfafefa", 130, 3.25)
};

初始化对象数组的方案是，首先使用默认构造函数创建数组元素，然后花括号中的构造函数将创建临时对象，然后将临时对象的内容复制到相应的元素中。因此，要创建对象数组，则这个类必须有默认构造函数。

第十一章：使用类

运算符重载

语法格式：operatorp(argument-list)其中最后一个p表示要重载的运算符，比如operator+(Time)

函数重载：函数重载的关键是函数的参数列表—也称为函数特征标(function signature)。如果两个函数的参数数目和类型相同，同时参数的排列顺序也相同，则他们的特征标相同，而变量名是无关紧要的。函数名相同而特征标不同的函数是重载函数。

double func(int a, double b) 和 double func(double a, int b)也是重载函数，后边有实验证明。

运算符重载的时候左侧的操作数应该是调用对象，比如A = B*2.75等价于A = B.operator*(2.75)。而A = 2.75*B会出错。

要实现A = 2.75*B可以通过友元函数来实现。

class Time
{
 private:
 ...
 public:
 ...
 friend Time operator*(double m, const Time & t);
};

这样再调用A = 2.75*B； 就等价于A = operator*(2.75, B)；

关于函数重载和左值是调用对象做了一个实验。

#include <iostream>

double func(int a, double b)
{
 std::cout<<"fir i"<<std::endl;
 return a+b;
}

double func(double b, int a)
{
 std::cout<<"fir dou"<<std::endl;
 return a+b;
}

int main()
{
 std::cout<<func(1, 2.3)<<std::endl;
 std::cout<<func(2.3, 1)<<std::endl;
 return 0;
}

上边程序的输出如下，符合预期。

$ ./a.out
fir i
3.3
fir dou
3.3

但是把第二个func函数的定义注释掉之后，使用clang编译的时候会出现./test.cpp:19:18: warning: implicit conversion from 'double' to 'int' changes value from 2.3 to 2 [-Wliteral-conversion] std::cout<<func(2.3, 1)<<std::endl;的警告。运行的时候会输出

$ ./a.out
fir i
3.3
fir i
3 //把2.3转换成了int型的2,所以出错了。

由此证明前边说的，参数列表中参数的顺序不同代表的是不同的函数。

类的自动转换和强制类型转换

第十二章：类和动态内存分配

静态类成员函数

使用static关键字将类成员函数声明为静态的。

声明为静态的类成员函数不能通过对象调用，也不能使用this指针。因为静态成员函数不与特定的对象相关联，因此只能使用静态数据成员。可以直接使用类名::函数名()调用，静态类数据成员的使用：类名::变量名。

C++ Primer

第九章：顺序容器(sequential-container)

顺序容器是按照他们在容器中的位置来顺序保存和访问的

顺序容器

vector : 可变大小数组，支持快速随机访问，在尾部之外的位置插入或者删除元素可能会很慢。
deque：双端队列
list ：双向链表，只支持双向顺序访问
forward_list：单向链表，只支持单向顺序访问
array：固定大小数组，支持快速随机访问，不能添加或者删除元素
string：与vector相似的容器，但专门用于保存字符，随机访问快。

array和forward是C++新标准增加的类型

额外三个顺序容器适配器

stack
queue
Priority_queue

适配器（adaptor）是标准库中的一个通用概念。容器、迭代器和函数都有适配器。本质上，一个适配器是一种机制，能使某种事物的行为看起来像另外一种事物一样。一个容器能接受一种已有的容器类型，使其行为看起来像另外一种不同的类型。例如stack适配器使用一种顺序容器，使其操作起来像一个stack一样。每个适配器都在其底层顺序容器类型之上定义了一个新的接口。

第十一章：关联容器(associative-container)

关联容器中的元素是按照关键字来保存和访问的

主要有两个

map: 元素是key-value对

set：每个元素只包含一个关键字，支持高效的关键字查询操作：检查一个给定的关键字是否在set中

共有八中形式

map : 关联数组：保存关键字-值对
set ：关键字即值，即只保存关键字的容器
multimap ：关键字可以出现多次的关键字-值对
multiset ：关键字可以重复出现多次的set

以下四个是无序的集合

unordered_map : 用哈希函数组织的map
unordered_set : 用哈希函数组织的set
unordered_multimap : 哈希函数组织的map，且关键字可以重复出现多次
unordered_multiset ：哈希函数组织的set, 且关键字可以重复出现多次

map和multimap定义在头文件map中

set和multiset定义在头文件set中

无序容器定义在unordered_map和unordered_set中。

使用关联容器的一个例子

#include <map>
#include <set>
#include <string>
using namespace std;

map<string, size_t> word_count;
set<string> exclude = {"The", "But", "And", "Or", "An", "A", "the"};

string word;
while (cin>>word)
 if (exclude.find(word) == exclude.end()) //find调用返回一个迭代器，如果给定关键字在set中，迭代器指向该关键字，否则find返回尾后迭代器。
 ++word_count[word];

侯婕-STL标准库和泛型编程

STL的六大部件:

容器（Containers）
分配器 (Allocators)
算法 (Algorithms)
迭代器 (Adapters)
仿函式 (Functors)

![image-20190727221102649](/Users/kevin/Library/Application Support/typora-user-images/image-20190727221102649.png)

下边一个程序用了六大组件。

# include <vector>
# include <algorithm>
# include <functional>
# include <iostream>
using namespace std;
int main()
{
 int ia[6] = {27, 210, 12, 47, 109, 83};
 vector<int, allocator<int> > vi(ia, ia+6);
 // vector是容器， allocator是分配器，负责底层内存的分配。
 count<<count_if(vi.begin(), vi.end(), not1(bind2nd(less<int>(), 40)));
 // vi.begin()和vi.end()是迭代器， count_if是算法：满足后边条件的元素数目
 // not1(否1，数字1)和bind2nd(绑定第二个参数：40)都是函数适配器，less是一个仿函数
 // 即输出大于等于40的数字个数
 return 0;
}

C++基础面试题

yuanye.ma@qq.com (Yuanye Ma) — Mon, 15 Apr 2019 16:01:23 +0800

const和指针

const int * a // a是一个指针，指向一个const int类型的内存， a本身可以修改指向别的变量，但是a所指向的内存中的数据不能修改。
int const * a // 和第一种相同
int * const a // const修饰的是a， a是一个int *型的变量。也就是说a本身不能修改，即指向确定的内存，但所指向的内存中的数据可以修改。
const int * const a // a以及a所指向的内存中的值都不能被修改。

主要看const后边修饰的是什么，

第一种const修饰的是int * a，那就是*a不能被改变，而a可以改变。
第二种const修饰的是* a, 同样*a不能改变，即指向的内存中的值不能改变。
第三种const修饰的是a，即a本身不能被修改，也就是说指向确定的内存空间，而*a内存中的值可以被改变。

结构体的内存对齐

#include <iostream>
#include <cstddef>

using namespace std;

struct a{
 char a;
 int b;
 short c;
 double d;
};

struct b{
 char a;
 short b;
 int c;
 float d;
};

int main()
{
 cout<<"sizeof(struct a) : "<<sizeof(struct a)<<" sizeof(struct b) : "<<sizeof(struct b)<<endl;
 cout<<"sizeof(short) : "<<sizeof(short)<<endl;
 cout<<"sizeof(int) : "<<sizeof(int)<<endl;
 cout<<"sizeof(long int) : "<<sizeof(long int)<<endl;
 cout<<"sizeof(long long int) : "<<sizeof(long long int)<<endl;
 cout<<"sizeof(flaot) : "<<sizeof(float)<<endl;
 cout<<"sizeof(double) : "<<sizeof(double)<<endl;


 printf("offset of b in struct a : %lu\n", offsetof(struct a, b));
 printf("offset of d in struct a : %lu\n", offsetof(struct a, d));
 printf("offset of b in struct b : %lu\n", offsetof(struct b, b));

 return 0;
}
程序在64位机器上的输出结果为
sizeof(struct a) : 24 sizeof(struct b) : 12
sizeof(short) : 2
sizeof(int) : 4
sizeof(long int) : 8
sizeof(long long int) : 8
sizeof(flaot) : 4
sizeof(double) : 8
offset of b in struct a : 4
offset of d in struct a : 16
offset of b in struct b : 2

结构体的内存对齐有以下

结构体变量的起始地址能够被其最宽的成员大小整除

结构体每个成员相对于起始地址的偏移能够被其自身大小整除，如果不能则在前一个成员后面补充字节

结构体总体大小能够被最宽的成员的大小整除，如不能则在后面补充字节

拿struct a 来说，

第一个成员是char类型的，占用一个字节，偏移地址为0。
第二个成员是int类型，本身占用4个字节，原本偏移为1，但是1不能被4整除，因此在a后边需要补充3个字节，这样b的起始地址偏移就变成了4，能够被自身大小整除，因此b的起始地址偏移为4。
第三个成员是short类型，本身占用2个字节，偏移为8，能够被本身大小整除。
第四个成员是double类型，本身占用8个字节，偏移为10，不能被本身大小整除，前一个c后边需要补充6个字节，也就是说double d的起始地址偏移为16。
最后，整个结构体占用24个字节，最宽的成员是double d占8个字节，24能被8整除，所以sizeof (struct a) = 24。

使用定义在 stddef.h 的宏offsetof(type, member) ，可以查看成员相对与结构体类型的偏移值

一道关于内存计算的题

#include <iostream>
#include <cstdio>

using namespace std;

int main()
{
 int array[2019]={0};
 array[19] = 2019;

 int offset = (unsigned long)((short *)array+2019) - (unsigned long)array + *(unsigned char *)(array+19);

 cout<<offset<<endl;

 printf("%p\n", 2019);

 printf("%p\n", array);
 cout<<(unsigned long)(array)<<endl;
 cout<<(unsigned long)((short *)array+2019)<<endl;
 cout<<(unsigned long)array+*(unsigned char *)(array+19)<<endl;
 cout<<(int)*(unsigned char *)(array+19)<<endl;

 return 0;
}
输出结果如下
4265
0x7e3 // 2019的十六进制，小端存储模式，所以在内存中应为 e3 07, 故*(unsigned char *)(array+19) = 0xe3 = 227
0x7ffeec55a800 // 64位机器输出的地址是64位的
140732863457280 // array的起始地址
140732863461318 // short占用两个字节 (unsigned long)((short *)array+2019)相当于array向后偏移了2*2019=4038个字节，因此地址值为array+4038
140732863457507 //
227

C++ 对象的存储方式

#include <iostream>
#include <string>

using namespace std;

class A{
public:
 A(){}
 ~A(){}

 void p(const string & s)
 {
 cout<<s<<endl;
 }
};

int main()
{
 A * p = NULL;
 p->p("hello world\n");
}

此程序能够正常编译运行输出hello world。

c++类方法存储在代码段，因此同一个类的所有方法公用代码段，p->p(“hello world\n”)；访问的是代码段，所以不会出现段错误或者core dump。

红黑树的性质

红黑树是每个节点都带有颜色属性的二叉查找树。在二叉查找树强制一般要求外，对于任何有效的红黑树增加额外的要求。

节点是红色或者黑色；
根是黑色的；
所有叶子节点都是黑色的（叶子是NIL节点）；
每个红色节点必须有两个黑色的子节点（或：从每个叶子节点到根的所有路径上不能有两个连续的红色节点）；
从任一节点到其每个叶子节点的所有简单路径都包含相同数目的黑色节点。

这些约束确保了红黑树的关键特性：从根到叶子的最长可能路径不多于最短的可能路径的两倍长。保证红黑树大致是平衡的。保证红黑树在最坏的请胯下也是高效的。

二叉查找树，也叫二叉搜索树、有序二叉树或者排序二叉树，是一颗空树或者具有以下性质的二叉树：

若任一节点的左子树不为空，则左子树上所有节点的值均小于它的根节点的值；
若任一节点的右子树不为空，则右子树上所有节点的值均大于它的根节点的值；
任意节点的左右子树也分别为二叉查找树；
没有键值相等的节点。

TCP三次握手和四次挥手

死锁

死锁：多个进程由于互相等待对方持有的资源而造成的谁都无法执行的情况叫死锁。

死锁产生的四个必要条件

互斥使用
不可抢占
请求和保持
循环等待

死锁处理方法

死锁预防：破坏死锁产生的条件；
- 一次性申请所有资源，不会占有资源还去申请其他资源
  - 缺点1：需要预知未来，编程困难
  - 缺点2：许多资源分配后很长时间后才使用，资源利用率低
- 对资源进行排序，资源申请必须按照顺序进行，不会出现环路等待
  - 缺点：仍然造成资源浪费
死锁避免：检测每个资源请求，如果会造成死锁就拒绝分配相应资源；
- 银行家算法
  - 请求出现时：首先假装分配，然后调用银行家算法，如果进程序列无法运行下去就拒绝。
  - 时间复杂度为， m为资源个数， n为进程的个数。
死锁检测+恢复：检测到死锁出现时，让一些进程回滚从而让出资源；
- 银行家算法每次申请都需要执行, 效率低：发现问题再处理
  - 定时检测或者发现资源利用率低时检测。
  - 选择哪些进程回滚？
  - 如何实现回滚？
死锁忽略 (windows, linux采用的方式)
- 代价最小
- PC重启影响小
- 死锁出现概率小

Linux I/O多路复用

聊聊IO多路复用之select、poll、epoll详解

epoll例程

Makefile中的一些神奇用法

yuanye.ma@qq.com (Yuanye Ma) — Mon, 15 Apr 2019 16:01:23 +0800

Makefile中的一些神奇用法

本文主要讲Makefile中的三个函数：
1、wildcard : 扩展通配符
2、notdir ：去除路径
3、patsubst ：替换通配符

前言

今天在读工程代码的时候无意间看到这样几行代码，大概意思猜出来了，但是说实话确实没注意过这样的用法，于是google一番，豁然开朗。

写一个例子看一下

先创建一下目录

.
├── a
│   ├── aa.c
│   ├── ab.c
│   └── ac.c
├── a.c
├── b.c
└── c.c

vim Makefile 并写入一下内容

1 SRC=$(wildcard *.c ./a/*.c)
2 DIR=$(notdir $(SRC))
3 OBJ=$(patsubst %.c, %.o, $(SRC))
4
5 all:
6 @echo $(SRC)
7 @echo $(DIR)
8 @echo $(OBJ)

执行make查看运行结果

a.c b.c c.c ./a/aa.c ./a/ab.c ./a/ac.c
a.c b.c c.c aa.c ab.c ac.c
a.o b.o c.o ./a/aa.o ./a/ab.o ./a/ac.o

分析执行过程

通过第一行的输出可以看出，wildcard的作用是用后边的通配符去匹配文件名。

通过第二行的输出可以看出，notdir的作用是省略掉文件名中的路径信息，只保留最后的文件名称。

通过第三行的输出可以看出，patsubst的作用是把$SRC中所有的.c文件名修改为.o

‘%’（百分号）表示匹配任意长度的子串

扩展

此外还有几种方法效果和 OBJ=$(patsubst %.c, %.o, $(SRC))一样

Makefile中的变量替换引用

`1`	`OBJ=$(SRC:.c=.o)`

Makefile中的自动推导规则

1
2

%.o:%.c
 gcc -c -o $@ $^

最后给出全部代码

1 SRC=$(wildcard *.c ./a/*.c)
2 DIR=$(notdir $(SRC))
3 #OBJ=$(patsubst %.c, %.o, $(SRC))
4 OBJ=$(SRC:.c=.o)
5
6 %.o:%.c
7 @echo $@
8 @echo $^
9 @gcc -c -o $@ $^
10
11 all:$(OBJ)
12 @echo $(SRC)
13 @echo $(DIR)
14 @echo $(OBJ)
15
16 clean:
17 rm -rf $(OBJ)

运行输出

a.o
a.c
b.o
b.c
c.o
c.c
a/aa.o
a/aa.c
a/ab.o
a/ab.c
a/ac.o
a/ac.c
a.c b.c c.c ./a/aa.c ./a/ab.c ./a/ac.c
a.c b.c c.c aa.c ab.c ac.c
a.o b.o c.o ./a/aa.o ./a/ab.o ./a/ac.o

shell中fork、exec和source的区别

yuanye.ma@qq.com (Yuanye Ma) — Mon, 15 Apr 2019 16:01:23 +0800

shell中fork、exec和source的区别

前言

在脚本中引用其他脚本有多种方式，直接执行./xx.sh，source xx.sh或者exec xx.sh,但是三种方式的本质是不通的。学过linux高级编程或者对linux进程创建方式比较熟悉的理解起来可能比较容易一些。

简介

./xx.sh

fork 创建一个子进程（sub-shell），然后在子进程中运行调用的脚本，子进程继承父进程的资源（环境变量等等），在子进程中修改父进程的环境变量后，子进程退出后，并不影响父进程。写脚本的时候直接./xx.sh就是采用这种方式。

. ./xx.sh 或者 source xx.sh

source 让 script 在当前 shell 内执行、而不是产生一个 sub-shell 来执行。因此source执行的脚本中可以更改父进程的环境变量。

exec ./xx.sh

exec 也是在原有进程中执行，但是，原有进程被终止。exec是用子进程替换父进程进行运行，所有父进程中exec后边的程序得不到运行。

注意

source和exec区别在于，原有进程是否被终止

实例分析

vim 1.sh 写入以下内容

1#!/bin/bash
2 A=B
3 echo "PID for 1.sh before exec/source/fork:$$"
4 export A
5 echo "1.sh: \$A is $A"
6 case $1 in
7 exec)
8 echo "using exec..."
9 exec ./2.sh ;;
10 source)
11 echo "using source..."
12 #. ./2.sh ;;
13 source ./2.sh;;
14 *)
15 echo "using fork by default..."
16 ./2.sh ;;
17 esac
18 echo "PID for 1.sh after exec/source/fork:$$"
19 echo "1.sh: \$A is $A"

vim 2.sh 写入以下内容

1 #!/bin/bash 
2 echo "PID for 2.sh: $$"
3 echo "2.sh get \$A=$A from 1.sh"
4 A=C
5 export A
6 echo "2.sh: \$A is $A"

分别运行
./1.sh fork
./1.sh source
./1.sh exec
运行结果

* ~/dep/selfcode *
root→ # ./1.sh fork
PID for 1.sh before exec/source/fork:31099
1.sh: $A is B
using fork by default…
PID for 2.sh: 31100
2.sh get $A=B from 1.sh
2.sh: $A is C
PID for 1.sh after exec/source/fork:31099
1.sh: $A is B

* ~/dep/selfcode *
root→ # ./1.sh source
PID for 1.sh before exec/source/fork:31105
1.sh: $A is B
using source…
PID for 2.sh: 31105
2.sh get $A=B from 1.sh
2.sh: $A is C
PID for 1.sh after exec/source/fork:31105
1.sh: $A is C

* ~/dep/selfcode *
root→ # ./1.sh exec
PID for 1.sh before exec/source/fork:31110
1.sh: $A is B
using exec…
PID for 2.sh: 31110
2.sh get $A=B from 1.sh
2.sh: $A is C
注意：父进程后边的代码没有运行

以上除了fork，父进程和子进程的PID不同外，source和exec父进程和子进程的PID相同，
但是，source相当于在父进程执行过程中插入了一段子进程的代码运行，
而exec是用子进程的代码替换掉了父进程的空间。

Shell编程中$(())与$()还有${}的区别

yuanye.ma@qq.com (Yuanye Ma) — Mon, 15 Apr 2019 16:01:23 +0800

Shell编程中$(())与$()还有${}的区别

先来看$()

在bash shell中, $()与``(反引号)都是用来做命令替换(command substitution)的。例如

`1`	`$ echo the last sunday is $(date -d "last sunday" +%Y-%m-%d)`

在操作上，用$()或``都无所谓,但在使用时有一些需要注意的地方。

反引号在多命令复合的时候需要加额外的转义，

即 command1 `command2 \`command3\` `

要不然换成$()就没有问题了

`1`	`command1 $(commmand2 $(command3))`

做多少层的替换都没有问题

$

接下来，再让我们看看${}吧…它其实就是用来做变量替换用的啦。一般情况下，$var与${var}并没有啥不一样。但是用${}会比较精准的界定变量名称的范围，比方说:

1
2

$ A=B
$ echo $AB

原本是打算先将$A的结果替换出来，然后在其后补一个字母B；但命令行上，真正的结果却是替换变量名称为AB的值出来… 若使用${}就没有问题了：

1
2

$ A=B
$ echo ${A}B #输出就是BB

例

#!/bin/bash

A=B
echo $A
echo $AB
echo $(A)B
echo ${A}b

输出如下：

B

./test.sh: line 6: A: command not found
B
Bb

此外${}还有更强大的功能

可以用${}分别替换获得不同的值

首先定义：

`1`	`file=/dir1/dir2/dir3/my.file.txt`

shell 字符串的非贪婪(最小匹配)左删除

`1`	`${file#*/} #其值为：dir1/dir2/dir3/my.file.txt`

拿掉第一个/及其左边的字符串，其结果为： dir1/dir2/dir3/my.file.txt 。

`1`	`${file#*.} #其值为：file.txt`

拿掉第一个.及其左边的字符串，其结果为： file.txt 。

shell 字符串的贪婪(最大匹配)左删除

`1`	`${file##*/} #其值为：my.file.txt`

拿掉最后一个/及其左边的字符串，其结果为： my.file.txt 。

`1`	`${file##*.} #其值为：.txt`

拿掉最后一个.及其左边的字符串，其结果为： txt 。

shell 字符串的非贪婪(最小匹配)右删除

`1`	`${file%/*} #其值为：/dir1/dir2/dir3`

拿掉最后一个/及其右边的字符串，其结果为： /dir1/dir2/dir3。

`1`	`${file%.*} #其值为：/dir1/dir2/dir3/my.file`

拿掉最后一个.及其右边的字符串，其结果为： /dir1/dir2/dir3/my.file。

shell 字符串的贪婪(最大匹配)右删除

`1`	`${file%%/*} #其值为：其值为空。`

拿掉第一个/及其右边的字符串，其结果为：空串。

`1`	`${file%%.*} #其值为：/dir1/dir2/dir3/my。`

拿掉第一个.及其右边的字符串，其结果为： /dir1/dir2/dir3/my。

shell 字符串取子串

1
2

${file:0:5} #提取最左边的5个字符：/dir1
${file:5:5} #提取第5个字符及其右边的5个字符:/dir2

shell 字符串取子串的格式：${s:pos:length}, 取字符串 s 的子串：从 pos 位置开始的字符(包括该字符)的长度为 length 的的子串；其中pos为子串的首字符，在 s 中位置； length为子串的长度；

Note: 字符串中字符的起始编号为0

shell 字符串变量值的替换

1
2

${file/dir/path} #将第一个dir替换为path：/path1/dir2/dir3/my.file.txt
${file//dir/path} #将全部的dir替换为path：/path1/path2/path3/my.file.txt

shell 字符串变量值的替换格式：

首次替换： ${s/src_pattern/dst_pattern} 将字符串s中的第一个src_pattern替换为dst_pattern。
全部替换： ${s//src_pattern/dst_pattern} 将字符串s中的所有出现的src_pattern替换为dst_pattern.

计算 shell 字符串变量的长度

`1`	`${#file} #其值为27, 因为/dir1/dir2/dir3/my.file.txt刚好为27个字符。`

bash 数组(array)的处理方法

一般而言, A="a b c def" 这样的变量只是将$A替换为一个字符串，但是改为 A=(a b c def), 则是将$A定义为数组….

数组替换方法可参考如下方法

1
2

${A[@]} #方法一
${A[*]} #方法二

以上两种方法均可以得到：a b c def, 即数组的全部元素。

访问数组的成员

${A[0]}其中，${A[0]}可得到a, 即数组A的第一个元素，而 ${A[1]}则为数组A的第二元素，依次类推。

数组的 length

1
2

${#A[@]} #方法一
${#A[*]} #方法二

以上两种方法均可以得到数组的长度: 4, 即数组的所有元素的个数。

回忆一下，针对字符串的长度计算，使用${#str_var}；我们同样可以将该方法应用于数组的成员:

${#A[0]}其中，${#A[0]}可以得到：1，即数组A的第一个元素(a)的长度；同理，${#A[3]}可以得到: 3, 即数组A的第4个元素(def)的长度。

数组元素的重新赋值

A[3]=xyz

$(())作用

$(())是用来作整数运算的。

在bash中， $(())的整数运算符号大致有这些：

+- * / #分别为"加、减、乘、除"。
% #余数运算,(模数运算)
& | ^ ! #分别为"AND、OR、XOR、NOT"运算。

例如：

$ a=5; b=7; c=2;
$ echo $(( a + b * c ))
19
$ echo $(( (a + b)/c ))
6
$ echo $(( (a * b) % c ))
1

在$(())中的变量名称，可以在其前面加 $符号来替换，也可以不用，如： $(( $a + $b * $c )) 也可以得到19的结果。

此外，$(())还可作不同进制(如二进制、八进制、十六进制)的运算，只是输出结果均为十进制的。

echo $(( 16#2a )) 输出结果为：42，(16进制的2a) 以一个实用的例子来看看吧 : 假如当前的umask是022,那么新建文件的权限即为：

1
2
3

$ umask 022
$ echo "obase=8; $(( 8#666 & (8#777 ^ 8#$(umask)) ))" | bc
644

事实上，单纯用(())也可以重定义变量值，或作 testing：

1
2
3

a=5; ((a++)) #可将$a 重定义为6
a=5; ((a--)) #可将$a 重定义为4
a=5; b=7; ((a< b)) #会得到0 (true)返回值。

Note:使用(())作整数测试时，请不要跟[]的整数测试搞混乱了。

STL入门

yuanye.ma@qq.com (Yuanye Ma) — Mon, 15 Apr 2019 16:01:23 +0800

复习

strcpy(str1, str2); // 字符串拷贝函数
strcat(str1, str2); // 字符串拼接函数，将str2的内容拼接到str1后边
strcmp(str1, str2); // 字符串比较函数， str1>str2时输出的是正整数，str1<str2时输出负整数，当str1和str2一样的时候输出0
strlen(str); // 输出字符串的长度，不包括'\0'
puts(str); // 输出字符串 类似于printf("%s", str);
gets(str); // 输入字符串， 可以输入空格

STL入门

vector

vector：可变长数组

创建vector的四种方法

// 第一种创建vector的方法
vector<double> values;

// 第二种创建vector的方法
vector<double> values1(20);

// 第三种创建vector的方法
vector<double> numbers(20, 2.3);
//不仅开辟了20个元素的空间，并且给每个元素赋初值为2.3

// 第四种创建vector的方法
double d[6] = {1,2,3,4,5,6};
vector<double> words(d+1, d+5);
// 给定一个区间，将区间内的数据拷贝到vector中作为初值。

修改vector的数据

//修改vector内部的数据
cout<<endl;
words[2] = 1;
vec_tra(words); //遍历

删除vector中的数据

// 从vecotr中删除元素
cout<<"before del size : "<<words.size()<<endl;
vec_tra(words);
words.pop_back();
cout<<"after del size : "<<words.size()<<endl;
vec_tra(words);

words.clear();
cout<<"after clear size : "<<words.size()<<endl;

迭代器

// 迭代器的应用
vector<double>::iterator it=words.begin(); //让it指向words的第一个元素
while(it!=words.end()){ // 如果it不指向words的最后一个元素，就执行循环体
 cout<<*it<<endl; // * 表示取内容， *it表示把
 it++; // it向后挪动一个元素的位置，指向下一个元素
}

for(vector<double>::iterator it=words.begin(); it!=words.end(); it++)
 cout<<*it<<endl;

stack

“先进后出”数据结构

#include <iostream>
#include <stack>

using namespace std;

int main()
{
 stack<char> st; // 创建一个栈容器

 char str[] = "abcdefgj";

 for(int i=0; str[i]!='\0'; i++)
 st.push(str[i]); // 将元素入栈

 // 出栈
 while(!st.empty()) {
 cout<<st.top()<<endl; // 获取栈顶元素
 st.pop(); // 将栈顶元素出栈
 }
}

stack三种操作：创建、入栈、出栈

queue

“先进先出"数据结构

#include <iostream>
#include <queue>

using namespace std;

int main()
{
 queue<char> q;
 char str[]="abckegf";

 // 入队
 for (int i=0; str[i]!='\0'; i++)
 {
 cout<<str[i]<<"入队"<<endl;
 q.push(str[i]);
 }
 cout<<"入队完成, 队列中元素个数"<<q.size()<<endl;

 // 出队
 while(!q.empty()) {
 cout<<"队头元素："<<q.front()<<endl;
 q.pop();
 cout<<"出队一个元素后队列中剩余元素个数"<<q.size()<<endl;
 }
 return 0;
}

queue三种操作：创建、入队、出队

set

#include <iostream>
#include <set> //引入头文件

using namespace std;

int main()
{
 set<int> st1; // 创建一个set容器
 set<int>::iterator it; // 创建一个set容器的迭代器

 if (st1.empty())
 cout<<"空set"<<endl;

 cout<<"插入四个元素"<<endl;
 st1.insert(10);
 st1.insert(20);
 st1.insert(50);
 st1.insert(30);
 cout<<"现在set中元素个数："<<st1.size()<<endl;

 cout<<"遍历set"<<endl;
 for (it=st1.begin(); it!=st1.end(); it++)
 cout<<*it<<endl;

 cout<<"查找30 : ";
 if(st1.find(30) != st1.end())
 cout<<"yes"<<endl;
 else
 cout<<"no"<<endl;

 cout<<"查找40 : ";
 if(st1.find(40) != st1.end())
 cout<<"yes"<<endl;
 else
 cout<<"no"<<endl;

 cout<<"删除30"<<endl;
 st1.erase(30);
 cout<<"删除后set中元素个数："<<st1.size()<<endl;
 cout<<"清空set"<<endl;
 st1.clear();
 cout<<"set中元素个数:"<<st1.size()<<endl;

 return 0;
}

创建、插入元素、删除元素、查找元素

map

#include <map>
#include <string>
#include <iostream>

using namespace std;

int main()
{
 map<int, string> id_name;
 map<int, string>::iterator it;

 cout<<"插入四个元素"<<endl;
 id_name[12] = "xiaoming";
 id_name[1] = "xiaohong";
 id_name[27] = "zhangsan";
 id_name[5] = "lisi";
 cout<<"现有元素个数："<<id_name.size()<<endl;

 //遍历
 cout<<"遍历"<<endl;
 for(it=id_name.begin(); it!=id_name.end(); it++)
 cout<<(*it).first<<" "<<(*it).second<<endl;

 // 查询
 if (id_name.count(12) != 0)
 cout<<"id_name[12] = "<<id_name[12]<<endl;
 else
 cout<<"id_name中没有key为12的元素"<<endl;

 if (id_name.find(17) != id_name.end())
 cout<<"id_name[17] = "<<id_name[17]<<endl;
 else
 cout<<"id_name中没有key为17的元素"<<endl;

 // 删除
 cout<<"删除key为12的元素"<<endl;
 id_name.erase(12);
 cout<<"删除后map中还有元素个数"<<id_name.size()<<endl;
 cout<<"删除后map中的元素为"<<endl;
 for(it=id_name.begin(); it!=id_name.end(); it++)
 cout<<(*it).first<<" "<<(*it).second<<endl;
 // 清空
 id_name.clear();
}

创建、插入元素、查找元素、删除元素

掌握下边统计字符出现次数的程序

#include <iostream>
#include <map>
#include <cstring>

using namespace std;

int main()
{
 map<char, int> wordt;
 char a[100000];
 cin>>a;
 int len = strlen(a);
 for (int i=0; i<len; i++)
 wordt[a[i]]++; // a[i]即字符串中的字符，是key， value是a[i]出现的次数
 // wordt[a[i]] 是 以a[i]为key对应的value的值,即a[i]出现的次数，
 // 后边的++是将次数加一的意思

 map<char, int>::iterator it;
 for (it=wordt.begin(); it!=wordt.end(); it++)
 {
 //cout<<(*it).first<<" "<<(*it).second<<endl;
 if((*it).second == 1)
 {
 cout<<(*it).first;
 //return 0;
 }
 }
 return 0;
}

string的常用操作

搜索操作

string类提供了6个不同的搜索函数，每个函数有4个重载版本。每个操作都返回一个string::size_type值。表示匹配发生位置的下标。如果搜索失败，则返回一个名为string::npos 的static成员。（const string::size_type npos=-1，是一个unsigned类型）

函数名	解释
s.find(args)	查找s中args第一次出现的位置
s.rfind(args)	查找s中args最后一次出现的位置
s.find_first_of(args)	在s中查找args中任何一个字符第一次出现的位置
s.find_last_of(args)	在s中查找args中任何一个字符最后一次出现的位置
s.find_first_not_of(args)	在s中查找第一个不在args中的字符
s.find_last_not_of(args)	在s中查找最后一个不在args中的字符
`args`的4种重载
类别	解释
—	—
c ,pos	从s中位置pos开始查找字符c， pos默认为0
s2, pos	从s中位置pos开始查找字符串s2， pos默认为0
cp, pos	从s中位置pos开始查找指针cp指向的以空字符串结尾的c风格字符串， pos默认为0
cp, pos, n	从s中位置pos开始查找指针cp指向的数组的前n个字符。pos和n无默认值

Eg1:

string name("AnnaBelle");
auto pos = name.find("Anna"); // pos = 0
auto pos = name.find("anna"); // pos = string::npos
string numbers("0123456789"), name("r2d2");
auto pos = name.find_first_of(numbers); // pos = 1
string dept("0375p3");
auto pos = dept.find_first_not_of(numbers); // pos = 4

Eg2:

string::size_type pos = 0;
// 每步循环查找name中下一个数字。
while ((pos = name.find_first_of(numbers, pos)) != string::npos) {
 cout<<"found number at index : "<<pos<<" element is "<<name[pos]<<endl;
 ++pos; // 如果忽略递增pos,将成为一个死循环
}

构造操作

函数	解释
string s(cp, n)	s是cp指向的数组中前n个字符的拷贝。此数组至少应该包含n个字符
string s(s2, pos2)	s是string s2从下标pos2开始的字符的拷贝
string s(s2, pos2, len2)	s是s2从下标pop2开始len2个字符的拷贝

这些构造函数接受一个string或者一个const char *参数，还接受指定拷贝多少个字符的参数。

const char *cp = "hello world!!"; // 以空字符结束的数组
char noNull[] = {'H','e'}; // 不是以空字符结束
string s1(cp); // 拷贝cp中的字符直到遇到空字符， s1 = "hello world!!"
string s2(noNull, 2); // 从noNull中拷贝两个字符
string s3(noNull); // 未定义，noNull不是以空字符结束的
string s4(cp+6, 5); // 从cp[6]开始拷贝5个字符 s4 = "world"
string s5(s1, 6, 5); // 从cp[6]开始拷贝5个字符 s5 = "world"
string s6(s1, 6); // 从cp[6]开始拷贝直到结尾 s6 = "world！！"
string s7(s1, 6, 20); // 从cp[6]开始拷贝直到结尾 s7 = "world！！"
string s8(s1, 16); // 抛出一个out_of_range异常

通常从const char *创建string时，只恨指向的数组必须以空字符结尾，拷贝操作遇到空字符时停止。如果未传递计数值且数组也未以空字符结尾，或者给定的计数值大于数组大小，则构造函数的行为是未定义的。

当从string拷贝字符串时，我们可以提供一个可选的开始位置和一个计数值。开始位置必须小于或者等于个定的string的大小。如果位置大于size，则构造函数抛出一个out_of_range异常。如果我们传递一个计数值，则从给定位置开始拷贝这么多个字符。不管要求拷贝多少个字符，最多拷贝到string的结尾。

substr

substr操作返回一个string

string s("hello world");
string s2 = s.substr(0, 5); // s2 = hello
string s3 = s.substr(6); // s3 = world
string s4 = s.substr(6, 11);// s4 = world
string s5 = s.substr(12); // 抛出一个out_of_range的异常

背包问题答题模板

yuanye.ma@qq.com (Yuanye Ma) — Mon, 15 Apr 2019 16:01:23 +0800

背包问题答题模板

0-1背包

每件商品只能拿一件或者不拿。

// 假设
int m; // 背包容量
int n; // 商品数量
int v[n]; // 商品的价值列表
int w[n]; // 商品的重量（cost）列表
int dp[n][m];

朴素二维数组方式

for （int i=1; i<=n; i++）{
 for (int j=1; j<=m; j++) {
 if (j>=v[i])
 dp[i][j] = max(dp[i-1][j], dp[i-1][j-w[i]]+v[i]);
 dp[i][j] = dp[i-1][j];
 }
}
return dp[m]; // dp数组的最后一个元素即为最优解。

滚动数组方式优化

for (int i=1; i<=n; i++) {
 for (int j=m; j>=w[i]; j--) {
 dp[j] = max(dp[j], dp[j-w[i]]+v[i]);
 }
}

一个AC的例程

#include <iostream>

using namespace std;

int v[1005];
int w[1005];

int dp[1005];

int main()
{
 int n,m;
 cin>>n>>m;
 for (int i=1; i<=n; i++)
 cin>>v[i]>>w[i];

 for (int i=1; i<=n; i++) {
 for (int j=m; j>=v[i]; j--) {
 dp[j] = max(dp[j], dp[j-v[i]]+w[i]);
 }
 }

 cout<<dp[m]<<endl;
 return 0;
}

关于dp数组的初始化

要求恰好装满背包时，初始时dp[0]=0，其他的dp[1...m]=负无穷。这样就可以保证最终得到的dp[m]是一种恰好装满背包的最优解。

如果没有恰好装满背包的要求而只是希望价格尽量大时，初始化时应该将dp[0...m]=0。

初始化时dp数组就是在没有任何物品放入背包时的合法状态。如果要求背包恰好装满，那么此时只有容量为0的背包可以在什么都不装且价值为0的情况下被"恰好装满"，其他容量的背包均没有合法的解，属于未定义的状态，应该被赋值为负无穷。

如果背包并非必须装满，那么任何容量的背包都有一个合法解”什么都不装“，这个解的价值为0，所以初始时状态的值也就全部为0.

完全背包

每件商品可以拿无数件。

滚动数组

for (int i=1; i<=n; i++) {
 for (int j=m; j>=w[i]; j--) {
 for (int k=0; k*w[i]<=j; k++)
 dp[j] = max(dp[j], dp[j-k*w[i]]+k*v[i]);
 }
}

优化

for (int i=1; i<=n; i++) {
 for (int j=w[i]; j<=m; j++) { // 放一件之后 还能放下 就继续放
 dp[j] = max(dp[j], dp[j-w[i]]+v[i]);
 }
}

一个AC的例程。

#include <iostream>

using namespace std;

int dp[1005];

int main()
{
 int n,m;
 cin>>n>>m;
 int v[1005];
 int w[1005];

 for (int i=1; i<=n; i++)
 cin>>v[i]>>w[i];

 for (int i=1; i<n; i++) {
 for (int j=v[i]; j<=m; j++) {
 dp[j] = max(dp[j], dp[j-v[i]]+w[i]);
 }
 }
 cout<<dp[m]<<endl;

 return 0;
}

多重背包

每件物品只能拿固定次。

朴素做法

for (int i=1; i<=n; i++) {
 for (int j=m; j>=0; j--) {
 for (int k=1; k<=s[i] && k*w[i]<=j; k++) { // s[i] 指第i件商品一共有多少件
 dp[j] = max(dp[j], dp[j-k*w[i]]+k*v[i]);
 }
 }
}

一个AC的例程。

#include <iostream>

using namespace std;

int dp[1005];

int main()
{
 int n,m;
 cin>>n>>m;

 int v[1005];
 int w[1005];
 int c[1005];

 for (int i=1; i<=n; i++) {
 cin>>v[i]>>w[i]>>c[i];
 }

 for (int i=1; i<=n; i++) {
 for (int j=m; j>=v[i]; j--) {
 for (int k=1; k<=c[i] && k*v[i]<=j; k++) {
 dp[j] = max(dp[j], dp[j-v[i]*k]+w[i]*k);
 }
 }
 }
 cout<<dp[m]<<endl;
 return 0;
}

二进制优化

另一种优化

这两种优化方式暂时没弄懂

混合背包

二维费用的背包问题

int n; // 商品数目
int v; // 约束1
int m; // 约束2

int c_v[n]; // 约束1的cost
int c_m[n]; // 约束2的cost

for (int i=1; i<=n; i++) {
 for (int j=v; j>=c_v[i]; j--) {
 for (int k=m; k>=c_m[i]; k--) {
 f[j][k] = max(f[j][k], f[j-c_v[i]][l-v_m[i]]+c);
 }
 }
}

下边是一道题的AC代码

#include <iostream>
using namespace std;

int v_v[1005];
int v_m[1005];
int w[1005];

int dp[1005][1005];

int main()
{
 int n, v, m;
 cin>>n>>v>>m;

 for (int i=1; i<=n; i++) {
 cin>>v_v[i]>>v_m[i]>>w[i];
 }

 for (int i=1; i<=n; i++) {
 for (int j=v; j>=v_v[i]; j--) {
 for (int k=m; k>=v_m[i]; k--) {
 dp[j][k] = max(dp[j][k], dp[j-v_v[i]][k-v_m[i]]+w[i]);
 }
 }
 }
 cout<<dp[v][m]<<endl;
 return 0;
}

跟我一起写Makefile

yuanye.ma@qq.com (Yuanye Ma) — Mon, 15 Apr 2019 16:01:23 +0800

makefile的自动化变量

1
2
3

$< 表示第一个依赖文件,即依赖目标中的第一个目标名字。如果依赖目标是以模式（即%）定义的，那么$<将是符合模式的一系列的文件集。注意是一个一个取出来的。
$^ 表示所有的依赖目标的集合。以空格分隔。如果在依赖目标中有多个重复的，会自动去除重复的依赖目标，只保留一份。
$@ 表示规则中的目标集。在模式规则中，如果有多个目标，那么$@就是匹配于目标中模式定义的集合。

静态模式

<targets ...> : <target-pattern> : <prereq-patterns>
 <commands>
 ...
其中
 targets: 定义了一系列的目标文件，可以有通配符，是目标的一个集合
 target-parrtern 是指明了targets的模式，也就是目标集模式
 prereq-parrterns 是目标的依赖模式，它对target-parrtern形成的模式再进行一次依赖目标的定义。

下面看一个例子

objs = foo.o bar.o
all: $(objs)

$(objs): %.o : %c
 $(CC) -c $(CFLAGS) &< -o $@

可以写成下边的样子
%.o:%.c:
 $(CC) -c $(CFLAGS) &< -o $@

例子中目标从$objs中获取， %.o是变量$objs的模式，及所有以.o结尾的目标。依赖模式是%.c，也就是所有.o文件替换为.c作为依赖的文件名。

书写命令

@:省略命令

1
2
3

exec:
 @echo "xxx正在编译"
make exec时输出 "xxx正在编译" 而隐藏了命令echo

-：忽略错误，标记不管命令出不出错都认为是成功的

1
2

clean :
 -rm -f *.o

使用变量

在makefile中变量是可以使用后边的变量来定义的。

foo = $(bar)
bar = $(ugh)
ugh = Huh?

all:
 echo $(foo)
#执行make输出Huh?

好处就是可以把变量的真实值推到后边定义；

缺点是一旦发生嵌套定义就会报错，或者导致不可预知的错误。

:=

这种方法定义的变量，前面的变量不能使用后边的变量，只能使用前边已经定义的变量。

x := foo
y := $(x) bar
x := later
其等价于
y := foo bar
x := later

a := $(b) bar
b := foo
则 a的值是 bar b的值是 foo

?=

1
2

FOO ?= bar
其含义是如果FOO没有被定义过，那么变量FOO的值就是bar，如果FOO先前被定义过，那么这条语句什么都不干。

+=

追加变量值

1
2
3

objects = main.o foo.o bar.o utils.o
objects += another.o
则$(objects)的值是 main.o foo.o bar.o utils.o another.o

隐含规则

老式风格的“后缀规则”

双后缀: 双后缀规则定义了一对后缀：依赖目标(源文件)的后缀和目标文件的后缀。比如 .c.o相当于 %.o:%.c。

1
2

.c.o:
 $(CC) -c $(CFLAGS) $(CPPFLAGS) -o $@ $<

单后缀：但后缀规则只定义一个后缀。

后缀规则不允许任何的依赖文件，如果有依赖文件的话，那就不是后缀规则，那些后缀统统被认为是文件名。