重视自底向上思想的有力证明——Legacy Code

最新推荐文章于 2022-04-29 11:23:00 发布
最新推荐文章于 2022-04-29 11:23:00 发布
阅读量200 收藏
点赞数
分类专栏： 知识点 2021湖南多校对抗赛系列题解
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_51945248/article/details/116245381
版权

部分目录


来源题解目录
比赛link

Unsolved 19 / 80 H Gym 100753H Legacy Code

题意应该是：
操作中要有::PROGRAM至少一个才有用
操作可以嵌套
问有几个无用的操作

Sample Input 1
2
SuperGame::PROGRAM 0
HelpPackage::HelpFunction 2
HelpPackage::HelpFunction SuperGame::PROGRAM

Sample Output 1
0

Sample Input 2
2
Loop::CallA 1
Loop::CallB
Loop::CallB 1
Loop::CallA

Sample Output 2
2

Sample Input 3
2
SuperGame::PROGRAM 1
SuperServer42::PROGRAM
SuperServer42::PROGRAM 1
SuperServer42::PROGRAM

Sample Output 3
0

应该是模拟题？
我超时了
思路是dfs找

#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include<math.h>
//#include<iostream>
//#include<algorithm>
#include<string>
//#include<sstream>
//#include<vector>
#include<map>
//#include<set>
//#include<ctype.h>
//#include<stack>
//#include<queue>
#ifdef LOCAL
FILE*FP=freopen("text.in","r",stdin);
//FILE*fp=freopen("text.out","w",stdout);
#endif
using namespace std;
#define ll long long
#define mem(a,b) memset(a,b,sizeof(a))
#define _forplus(i,a,b) for( register int i=(a); i<=(b); i++)
#define _forsub(i,a,b) for( register int i=(a); i>=(b); i--)
#define ALL(x) x.begin(),x.end()
#define INS(x) inserter(x,x.begin())
#define INF 0x3f3f3f3f
#define pi (acos(-1))
#define N 405
struct Node{
	int flag=0;//默认无效 
	char it[N];//存操作 读入 
	int k;//子个数 读入 
	char cto[N][N];//子去处名称 读入 
}node[N];
map<string,int>m;//子去处记录 读完出 小心死循环超时 
//注意：char*作为指针，是不能判断字符串的，只能判断存放地址 
//并且string 可以兼容 char[] ，我只修改了这里   
int vis[N];//看每一个时防止死循环 
int n,cnt=0;
bool jd(char*str){
	char*p=strchr(str,':')+2;
	//printf("%s\n",p);
	if(strcmp(p,"PROGRAM")==0)return true;
	else return false;
}//判断该字符串是否能有效 
bool bfs(int now){
	if(jd(node[now].it)){
		return true;
	}else{
		vis[now]=1;
		_forplus(i,1,node[now].k){
			int sx=m[node[now].cto[i]];
			if(!vis[sx]){
				if(bfs(sx)){
					return true;
				}
			}
		}
	}
	return false;
	
}
int main(){
	scanf("%d",&n);
	_forplus(i,1,n){
		scanf("%s",node[i].it);
		scanf("%d",&node[i].k);
		_forplus(j,1,node[i].k){
			scanf("%s",node[i].cto[j]);
		}
	}
	_forplus(i,1,n){
		m[node[i].it]=i;
	}
	_forplus(i,1,n){
		mem(vis,0);
		if(bfs(i)){
			cnt++;
		}
	}
	printf("%d",n-cnt);
	return 0;
}

错是不会错的，但是有很多重复计算
我要用上标记这个是否是，减少重复计算

#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include<math.h>
//#include<iostream>
//#include<algorithm>
#include<string>
//#include<sstream>
//#include<vector>
#include<map>
//#include<set>
//#include<ctype.h>
//#include<stack>
//#include<queue>
#ifdef LOCAL
FILE*FP=freopen("text.in","r",stdin);
//FILE*fp=freopen("text.out","w",stdout);
#endif
using namespace std;
#define ll long long
#define mem(a,b) memset(a,b,sizeof(a))
#define _forplus(i,a,b) for( register int i=(a); i<=(b); i++)
#define _forsub(i,a,b) for( register int i=(a); i>=(b); i--)
#define ALL(x) x.begin(),x.end()
#define INS(x) inserter(x,x.begin())
#define INF 0x3f3f3f3f
#define pi (acos(-1))
#define N 405
struct Node{
	int flag=0;//默认0 有效1 无效-1 减少重复 
	char it[N];//存操作 读入 
	int k;//子个数 读入 
	char cto[N][N];//子去处名称 读入 
}node[N];
map<string,int>m;//子去处记录 读完出 小心死循环超时 
//注意：char*作为指针，是不能判断字符串的，只能判断存放地址 
//并且string 可以兼容 char[] ，我只修改了这里   
int vis[N];//看每一个时防止死循环 
int n,cnt=0;
bool jd(char*str){
	char*p=strchr(str,':')+2;
	//printf("%s\n",p);
	if(strcmp(p,"PROGRAM")==0)return true;
	else return false;
}//判断该字符串是否能有效 
bool bfs(int now){
	if(node[now].flag==1){
		return true;
	}
	if(node[now].flag==-1){
		return false;
	}//flag减少重复 
	if(jd(node[now].it)){
		node[now].flag=1;
		return true;
	}else{
		vis[now]=1;
		_forplus(i,1,node[now].k){
			//printf("in %d order: %d\n",now,i);
			int sx=m[node[now].cto[i]];
			if(sx==0)continue;//如果根本没有这个操作 
			if(!vis[sx]){
				if(bfs(sx)){
					return true;
				}
			}
		}
	}
	node[now].flag=-1;
	return false;
	
}
int main(){
	scanf("%d",&n);
	_forplus(i,1,n){
		scanf("%s",node[i].it);
		scanf("%d",&node[i].k);
		_forplus(j,1,node[i].k){
			scanf("%s",node[i].cto[j]);
		}
	//printf("first order: %d\n",i);
	}
	_forplus(i,1,n){
		m[node[i].it]=i;
	//printf("second order: %d\n",i);
	}
	_forplus(i,1,n){
	//printf("third order: %d\n",i);
		mem(vis,0);
		if(bfs(i)){
			cnt++;
		}
	}
	printf("%d",n-cnt);
	return 0;
}

结果：这个样例过了，下一个样例又超时了
难过，，，
cf上太长了无法完全显示。。。
和正确答案对拍没有错
看来就是被卡超时了

我看到CF上最快的代码
都没有用数据结构存储
他们的想法真是神奇

#include<bits/stdc++.h>
#define MAX_N 200000
#define ll long long
#ifdef LOCAL
FILE*FP=freopen("text.in","r",stdin);
//FILE*fp=freopen("text2.out","w",stdout);
#endif
using namespace std;
unordered_map<string,int>num;
int vis[500];
vector<int>g[405];
vector<int>vec;
int main(){
   //freopen("text.in","r",stdin);
   std::ios::sync_with_stdio(false);
   int n;
   string sta="::PROGRAM";
   string tmp;
   cin>>n;
   int cnt=1;
   for(int i=0;i<n;i++){
        int u=0;
        cin>>tmp;
        if(num[tmp]==0){
            num[tmp]=cnt++;
           // cout<<tmp<<"  "<<cnt-1<<endl;
            if(vis[num[tmp]]==0&&tmp.find(sta)!=tmp.npos){
                int t=tmp.find(sta);
               if(t+9==tmp.length())
               {vec.push_back(num[tmp]);
               vis[num[tmp]]=1;}
            }
        }
        u=num[tmp];
        int k;
        cin>>k;
        for(int j=0;j<k;j++){
            cin>>tmp;
            if(num[tmp]==0){
             num[tmp]=cnt++;
            //cout<<tmp<<"  "<<cnt-1<<endl;
             if(vis[num[tmp]]==0&&tmp.find(sta)!=tmp.npos){
               int t=tmp.find(sta);
               if(t+9==tmp.length())
               {vec.push_back(num[tmp]);
               vis[num[tmp]]=1;}
            }
         }
         g[num[tmp]].push_back(u);
        }
   }
   int c=vec.size();
   vector<int>nxt;
   while(vec.size()!=0){
        for(int i=0;i<vec.size();i++){
            int u=vec[i];
            for(int j=0;j<g[u].size();j++){
                int v=g[u][j];
                if(vis[v]==0){
                   // cout<<v<<endl;
                    nxt.push_back(v);
                    vis[v]=1;
                    c++;
                }
            }
        }
        vec=nxt;
        nxt.clear();
   }
   printf("%d\n",n-c);
   return 0;
}

但是看不太懂，，
找了一个水绿朋友的，还是这有共同语言www

知识点：智能指针

for(auto v: adj[u])
智能指针，遍历后面的数组元素

代码大意：
自底向上，往往高效
存储方法不同：
我是按原来的，一个下有哪些操作
他为了自底向上花了些心思，一个操作属于哪些子操作
只要这些子操作有效，那么该子操作上所有操作有效
再有一个vis数组防止重复
一个操作既然有效，如果他没dfs过，递归dfs，它上面的操作都有效

#include <bits/stdc++.h>
 
using namespace std;
#ifdef LOCAL
FILE*FP=freopen("text.in","r",stdin);
//FILE*fp=freopen("text.out","w",stdout);
#endif
#define st first
#define nd second
#define pb push_back
#define db(x) cerr << #x << " == " << x << endl
#define dbs(x) cerr << x << endl
#define _ << ", " <<
 
typedef long long ll;
typedef long double ld;
typedef pair<int,int>pii;
typedef pair<int,pii>piii;
typedef pair<ll,ll> pll;
typedef pair<ll,pll> plll;
typedef vector <int> vi;
typedef vector <vi> vii;
 
const ld EPS = 1e-9, PI = acos(-1.);
const ll LINF = 0x3f3f3f3f3f3f3f3f;
const int INF = 0x3f3f3f3f, MOD = 1e9+7;
const int N = 1e3+5;
 
map<string,int> num;
map<int,int> mark;
int n, vis[N], cnt, k, ans;
vi adj[N];
vector <string> names[N];
 
void add_vert(string y){
    string cmp = "PROGRAM", aux;
    int l = 0;
    for(int i=0; i < y.size();i++){
        if(y[i] == ':'){
            l++;
            continue;
        }
        if(l < 2) continue;
        aux += y[i];
    }
    if(aux == cmp) mark[num[y]] = 1;
}
 
void dfs(int u){
    ans++;
    vis[u] = 1;
    for(auto v: adj[u]){
        if(!vis[v]) dfs(v);
    } 
}
 
int main(){
    ios_base::sync_with_stdio(false);
    cin.tie(NULL);
    cin >> n;
    for(int i=1; i <= n; i++){
        string s;
        cin >> s;
        num[s] = i;
        add_vert(s);
        cin >> k;
        for(int j=0;j<k;j++){
            string x;
            cin >> x;
            names[i].pb(x);
        }
    }
    for(int i=1; i<=n; i++){
        for(int j=0;j<names[i].size();j++){
            adj[num[names[i][j]]].pb(i);
        }
    }
    for(int i=1;i<=n;i++){
        if(mark[i] and !vis[i]) dfs(i);
    }
    cout << n - ans << "\n";
    return 0;
}

我发现了是因为一个地方没有标flag超时
但是改过后在第53例wa了
数据很长的那种
很长时间都不觉得自己错了
就好挫败
以后多自底向上编，有条理
最后我花了5个小时看一个代码还是不知道自己哪错了
今天恰好EC final ，斌姐姐最后一次上场，我真希望他能实现自己的心愿夺金啊
我和他同甘共苦，不虚此行

#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include<math.h>
//#include<iostream>
//#include<algorithm>
#include<string>
//#include<sstream>
//#include<vector>
#include<map>
//#include<set>
//#include<ctype.h>
//#include<stack>
//#include<queue>
#ifdef LOCAL
FILE*FP=freopen("text.in","r",stdin);
//FILE*fp=freopen("text.out","w",stdout);
#endif
using namespace std;
#define ll long long
#define mem(a,b) memset(a,b,sizeof(a))
#define _forplus(i,a,b) for( register int i=(a); i<=(b); i++)
#define _forsub(i,a,b) for( register int i=(a); i>=(b); i--)
#define ALL(x) x.begin(),x.end()
#define INS(x) inserter(x,x.begin())
#define INF 0x3f3f3f3f
#define pi (acos(-1))
#define N 600
struct Node{
	int flag=0;//默认0 有效1 无效-1 减少重复 
	char it[N];//存操作 读入 
	int k;//子个数 读入 
	char cto[N][N];//子去处名称 读入 
}node[N];
map<string,int>m;//子去处记录 读完出 小心死循环超时 
//注意：char*作为指针，是不能判断字符串的，只能判断存放地址 
//并且string 可以兼容 char[] ，我只修改了这里   
int vis[N];//看每一个时防止死循环 
int n,cnt=0;
bool jd(char*str){
	char*p=strchr(str,':')+2;
	//printf("%s\n",p);
	if(strcmp(p,"PROGRAM")==0)return true;
	else return false;
}//判断该字符串是否能有效 
bool bfs(int now,int cnt){
	if(now==200)
			if(n==400&&node[1].k==398){
			int i=200;
			printf("%s %d %d %d\n",node[i].it,node[i].k,node[i].flag,cnt);
		}
	vis[now]=1;
	if(node[now].flag==1){
		return true;
		if(now==200)
			if(n==400&&node[1].k==398){
			int i=200;
			printf("f1:%s %d %d %d\n",node[i].it,node[i].k,node[i].flag,cnt);
		}
	}
	if(node[now].flag==-1){
		if(now==200)
			if(n==400&&node[1].k==398){
			int i=200;
			printf("f2:%s %d %d %d\n",node[i].it,node[i].k,node[i].flag,cnt);
		}
		return false;
	}//flag减少重复 
	if(jd(node[now].it)){
		node[now].flag=1;
		if(now==200)
			if(n==400&&node[1].k==398){
			int i=200;
			printf("second:%s %d %d %d\n",node[i].it,node[i].k,node[i].flag,cnt);
		}
		return true;
	}else{
		_forplus(i,1,node[now].k){
			//printf("in %d order: %d\n",now,i);
			int sx=m[node[now].cto[i]];
			if(sx==0)continue;//如果根本没有这个操作 
			if(!vis[sx]){
				if(bfs(sx,cnt+1)){
					node[now].flag=1;//记得找到子串后，递归回来也要标可以，避免重复！！
					//可由我们返回就是该字符串有效，flag也是这个用想到 
					if(now==200)
			if(n==400&&node[1].k==398){
			int i=200;
			printf("third:%s %d %d %d\n",node[i].it,node[i].k,node[i].flag,cnt);
		}
					return true;
				}
			}
		}
	}
		if(now==200)
			if(n==400&&node[1].k==398){
			int i=200;
			printf("last:%s %d %d %d\n",node[i].it,node[i].k,node[i].flag,cnt);
		}
	node[now].flag=-1;
	return false;
	
}
int main(){
	scanf("%d",&n);
	_forplus(i,1,n){
		scanf("%s",node[i].it);
		scanf("%d",&node[i].k);
		_forplus(j,1,node[i].k){
			scanf("%s",node[i].cto[j]);
		}
	//printf("first order: %d\n",i);
	}
	_forplus(i,1,n){
		m[node[i].it]=i;
	//printf("second order: %d\n",i);
	}
	if(n==400&&node[1].k==398){
			int i=200;
			printf("%s %d \n",node[i].it,node[i].k);
			_forplus(j,200,node[i].k){
				if(jd(node[i].cto[j]))
				printf("this:%s\n",node[i].cto[j]);
			}
		}
	_forplus(i,1,n){
	//printf("third order: %d\n",i);
	/*if(i==200)
			if(n==400&&node[1].k==398){
			int i=200;
			printf("%s %d %d\n",node[i].it,node[i].k,node[i].flag);
			_forplus(j,200,node[i].k){
				printf("%s %d\n",node[i].cto[j],node[m[node[i].cto[j]]].flag);
			}
		}*/
		mem(vis,0);
		if(bfs(i,1)){
			cnt++;
		}

		
	}
	printf("%d\n",n-cnt);
	/*
	int sum=0;
	_forplus(i,1,n){
		if(node[i].flag==1){
			sum++;
		}
	}
	printf("%d",n-sum);
	//由此，为flag就标错了
	*/
	//查看数据
	if(n==400&&node[1].k==398){
		/*_forplus(i,1,n){
			if(node[i].flag==-1){
				printf("%d ",i);
			}
		}*/
		/*int i=200;
		printf("%s %d\n",node[i].it,node[i].k);
		_forplus(j,1,node[i].k){
			printf("%s %d\n",node[i].cto[j],node[m[node[i].cto[j]]].flag);
		}*/
		/*char *st=node[199].it;
		int flag=0;
		_forplus(i,1,n){
			flag=0;
			_forplus(j,1,node[i].k){
				if(!strcmp(node[i].cto[j],st)){
					flag=1;
				}
			}
			if(!flag){
				printf("%d\n",i);
			}
		}*/
	} 
	return 0;
}

——————
晚上一想，睡前想到了。
沉心静气很重要，甘做冷板凳很重要
每一次的失败，都是为最后的成功前进
——崇桂书老师
我看了整整5个小时，都调不出错误啊，感动死我了
WA样例：

3
A::A 2
C::C B::PROGRAM
B::PROGRAM 0

C::C 1
A::A

由于我的vis是走过了一个就不dfs这个了，会有漏解的情况
应该是vis哪个就在dfs中不看哪个才好，
比如上面，漏了C：：C
否决：等价的不能换
想法2：如果一来一回，就往后扫
问题：不止一来一回，可能有三重四重，难以回去找到是第几层的DFS

总之，自顶向下写程序就是没有自底向上写程序好啦，我算是见识了
就光从DJ记录父节点而不能记录子节点就知道，
在这种有路径的图结构中（这个题可以认为是个图结构看）
自底向上百般好有条理有唯一性
自顶向下没有唯一性有分支，而知道了叶子即这里的::PROGRAM节点就可以追溯父节点没有分支，就十分有条理
应该从结果开始，动态规划回来的
试图修正的代码如下：

/*
错误原因：
自顶向下的多重来回，vis了的skip了之后的可能性，会漏解错解 
如果要再重新vis时略过，要记录是哪一个循环的哪一号，太麻烦
如果要等到回到那一层再把这层也记上，也很麻烦
但是要记录要做的话，每次开一个数组记录也不是不行，反正最多400层 
但是由于什么都要看，超时了，dfs调用太多次了 

还是自底向上DP解决才好 
有根据，有方向，不超时 
错误样例： 
3
A::A 2
C::C B::PROGRAM
B::PROGRAM 0

C::C 1
A::A 
*/
#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include<math.h>
//#include<iostream>
//#include<algorithm>
#include<string>
//#include<sstream>
//#include<vector>
#include<map>
//#include<set>
//#include<ctype.h>
//#include<stack>
//#include<queue>
#ifdef LOCAL
FILE*FP=freopen("text.in","r",stdin);
//FILE*fp=freopen("text.out","w",stdout);
#endif
using namespace std;
#define ll long long
#define mem(a,b) memset(a,b,sizeof(a))
#define _forplus(i,a,b) for( register int i=(a); i<=(b); i++)
#define forplus(i,a,b) for( register int i=(a); i<(b); i++)
#define _forsub(i,a,b) for( register int i=(a); i>=(b); i--)
#define ALL(x) x.begin(),x.end()
#define INS(x) inserter(x,x.begin())
#define INF 0x3f3f3f3f
#define pi (acos(-1))
#define N 405
struct Node{
	int flag=0;//默认0 有效1 无效-1 减少重复 
	char it[N];//存操作 读入 
	int k;//子个数 读入 
	char cto[N][N];//子去处名称 读入 
}node[N];
map<string,int>m;//子去处记录 读完出 小心死循环超时 
//注意：char*作为指针，是不能判断字符串的，只能判断存放地址 
//并且string 可以兼容 char[] ，我只修改了这里   
//int vis[N];//看每一个时防止死循环 
int ct[N]={1};//判层计数，1 ,替换vis，功能更强大 
int n,cnt=0;
inline bool jd(char*str){
	char*p=strchr(str,':')+2;
	//printf("%s\n",p);
	if(strcmp(p,"PROGRAM")==0)return true;
	else return false;
}//判断该字符串是否能有效 
inline bool bfs(int now){
	if(node[now].flag==1){
		return true;
	}
	if(node[now].flag==-1){
		return false;
	}//flag减少重复 
	if(jd(node[now].it)){
		node[now].flag=1;
		return true;
	}else{
		//vis[now]=1;
		_forplus(i,ct[now],node[now].k){
			ct[now]=i+1;
			//printf("in %d order: %d\n",now,i);
			int sx=m[node[now].cto[i]];
			if(sx==0)continue;//如果根本没有这个操作 
			//if(!vis[sx]||ct[sx]!=1){
				if(bfs(sx)){
					node[now].flag=1;//记得找到子串后，递归回来也要标可以，避免重复！！
					//可由我们返回就是该字符串有效，flag也是这个用想到 
					return true;
				}
			//}
		}
	}
	node[now].flag=-1;
	return false;
	
}
int main(){
	scanf("%d",&n);
	_forplus(i,1,n){
		scanf("%s",node[i].it);
		scanf("%d",&node[i].k);
		_forplus(j,1,node[i].k){
			scanf("%s",node[i].cto[j]);
		}
	//printf("first order: %d\n",i);
	}
	_forplus(i,1,n){
		m[node[i].it]=i;
	//printf("second order: %d\n",i);
	}
	_forplus(i,1,n){
	//printf("third order: %d\n",i);
		//mem(vis,0);
		forplus(i,1,n){
			ct[i]=1;
		} 
		if(bfs(i)){
			cnt++;
		}
	}
	printf("%d",n-cnt);
	return 0;
}
出尘呢
关注
专栏目录
KWin、libdrm、DRM从上到下全过程 —— drmModeAddFBxxx（10）
phmatthaus的专栏
10-24 185
KWin、libdrm、DRM从上到下全过程 —— drmModeAddFBxxx（10）
史上最全wireshark使用教程，8万字整理总结，建议先收藏再耐心研读
热门推荐
孙叫兽的博客
07-14 3万+
目录 第1章介绍... 1 1.1.什么是Wireshark. 1 1.1.1.主要应用... 1 1.1.2.特性... 1 1.1.3.捕捉多种网络接口... 2 1.1.4.支持多种其它程序捕捉的文件... 2 1.1.5.支持多格式输出... 2 1.1.6.对多种协议解码提供支持... 2 1.1.7.开源软件... 2 1.1.8.Wireshark不能做的事... 2 1.2.系通需求... 2 1.2.1.一般说明... 2 ...
LegacyCode:遗留代码重构项目
06-27
##重构遗留代码 基于 无需测试即可重构 PHP Legacy 代码应用程序。 使用标签查看重构的不同阶段 阶段 初始 -> 启动重构项目 First Output Test -> Create first test 将输出保存到文件 常量和魔术字符串 -> 自动加载和提取变量。 复杂的条件 -> 要简单 游戏测试方法 -> 简单测试 复杂的方法 -> 困难的测试 表示层->职责分离 Inyection 依赖 -> 创建接口 分析关注点 -> 转到 OOP 并考虑未来的工作
基于模型开发之代码集成——LegacyCodeTool
动感小麦兜的博客
04-09 5132
两种比较简单的方法可以将代码集成到模型中。   1、使用Legacy Code Tool来集成C代码到Simulink模型   2、在StateFlow建模过程中使用CustomCode 集成或调用已有C代码 LegacyCodeTool简要说明   Legacy Code Tool是Matlab中的一个命令行工具，它可以很方便的将已有的C
关于legacy code学习笔记
edison702的专栏
11-26 2044
legacy code是目前很多公司面临的问题，就是这些code有用但是需要很多精力或者程序员去学习才能维护。  比如说你自己三年前些的代码，因为文档不完全而现在自己都几乎看不懂了，也是legacy code的一种。    一个比较好的处理办法是对code加上测试， 针对rails代码来说：     1.   看database schema      2.  看class之间的联系， r
程序猿的终极噩梦，祖传代码，一动，修半年
python2021_的博客
04-29 1735
“祖传代码，轻则伤筋动骨，重则一命呜呼” 程序猿的终极噩梦应该是祖传代码了吧。 很多码农小萌新们，都经历过这样的时刻吧。矜矜业业检查前人代码时，发现了明显到觉得智障的漏洞，认真的你准备大刀阔斧地修改，但你的老司机同事可能会劝你最好不要动，并露出意味深长的表情。 因为他们知道，你遇到了祖传代码。 什么是祖传代码？ 祖传代码（legacy code），就字面意思而言，就是老程序猿留下“宝藏”代码。可能当初写代码的人早就离开了，但代码逻辑混乱又无注释，后人完全看不出来写的是个啥！ 要么就是前人写下的时候就不完美，
Simulink代码生成：通过Legacy Code Tool集成C函数
u013288925的博客
09-01 5511
本文通过一个例程来简述如何使用Legacy Code Tool将外部C函数集成到Simulink模型中。 文章目录1 问题引入2 编译器安装3 Legacy Code Tool简单示例3.1 创建C文件和头文件3.2 通过LCT生成S-function模块3.3 模型仿真3.4 代码生成4 总结 1 问题引入 假设一个公司在旧的项目中，没有通过Simulink建模并生成代码，而是纯手写的C代码。在新的项目中应用了Matlab的这一套工具链进行MBD开发，想要在模型中直接调用以前写的C函数可以吗？ 答案是肯定
Linux驱动分析——input输入子系统
fang_yang_wa的博客
01-27 1705
1、朱有鹏老师的视频课程笔记和应用测试代码： ***********《朱有鹏老师嵌入式linux核心课程》 *********** 《5.linux驱动开发-第5部分-5.8.input子系统基础之按键》 -------------------------------------------------------- 本课程由朱老师物联网大讲堂推出并提供技术支持，课件可打包下载 网盘地址：http://yunpan.cn/cjVy3RAgfDufK 访问密码 4ad7 技术交流QQ群：朱老师物联网讲堂
Vue源码分析——第一章
Lee的博客
09-09 2019
Vue最新版本源码分析，每个函数功能注释的很清楚，重点模块逐行注释！ /*! * Vue.js v2.6.9 * (c) 2014-2019 Evan You * Released under the MIT License. */ (function (global, factory) { typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() : .
修改软件的艺术(Beyond legacy code) 英文版
05-31
敏捷和精益开发越来越普及，是软件开发的趋势。 敏捷需要软件过程，而且需要理解敏捷过程的原理。但更重要的是软件开发的技术，没有技术的过程会变成空架子。本书介绍的基本的9个开发技术。 然而感觉书名不很贴切。内容并不是如何修改已有代码。
Android高级面试题汇总——Android篇（1）
msc694955868的博客
10-24 990
（一）Android基础知识点 1、四大组件是什么 Activity，Service，ContentProvider，BroadcastReceiver 2、四大组件的生命周期和简单用法 Activity的生命周期：onCreate()->onStart()->onResume()->onPause()->onStop()->onRestart()->onDestroy() 用法：创建一个Intent对象，将该Ac...
Legacy CodeForces - 787D （线段树优化建图+最短路）
FLY_WHITE的博客
09-22 1139
Legacy  CodeForces - 787D  Rick and his co-workers have made a new radioactive formula and a lot of bad guys are after them. So Rick wants to give his legacy to Morty before bad guys catch them. Th...
lorenz系统simulink仿真_Legacy code toolsC编程和Simulink建模的桥梁
weixin_39632693的博客
11-28 533
最近公司有一部分代码移植的工作，涉及到C code和Simulink模型的集成工作。上一周花了点时间研究Legacy code tools，打通C程序-Simulink模型。使用Legacy code tools(LCT)有两个好处：- Matlab/Simulink环境下仿真手写的C函数-把手写代码集成到Simulink环境中，手写代码开发切换到基于模型开发Prepartion wo...
Legacy Code Tool范例
issta的博客
01-17 642
如图所示： 如果被调用的函数既没有输入参数，也没有返回值，也是可以的~~ lct_spec = legacy_code('initialize'); lct_spec.Options.language = 'C'; lct_spec.SFunctionName = 'sfun_LegacyCode'; lct_spec.SourceFiles = {'LegacyCode.c'}...
time(NULL)用法
出尘的博客
02-26 4625
time(NULL);就是返回从1970年元旦午夜0点到现在的秒数。 time的返回值和其参数都能用来接收这个数值，效果是一样的。
五种文件输入输出方式大总结
出尘的博客
03-30 2854
先介绍文件输入输出，要用到： 模式 描述 “r” 打开一个用于读取的文件。该文件必须存在。 “w” 创建一个用于写入的空文件。如果文件名称与已存在的文件相同，则会删除已有文件的内容，文件被视为一个新的空文件。 “a” 追加到一个文件。写操作向文件末尾追加数据。如果文件不存在，则创建文件。 “r+” 打开一个用于更新的文件，可读取也可写入。该文件必须存在。 “w+” 创建一个用于读写的空文件。 “a+” 打开一个用于读取和追加的文件。 总结： 规律 r
旅行商问题之状压DP——旅行商变体之贪心法——旅行商问题之思考&&比较遗传算法退火算法_——重新补最短路基础未完成—— A Journey to Greece
出尘的博客
04-29 1786
部分目录Unsolved 18 / 85 A Gym 100753A A Journey to Greece官方题解：TSP变体TSP问题——大名鼎鼎的旅行商问题解法方法1：状压DP法附：遗传算法的乌龙刚刚在上面发现一个新问题：状压DP不能保证每个点只走一次？那么有一个解决方法，如果要只经过一次的话，也就是只给状压经过，求最短路时不要经过（只不重复要参观的城市）：我们是不是可以不重复所有的城市？（超时超空间，，解决，，可能要调数据范围AC）对于标准的TSP，我们是否可以不管重复不重复，只要走过所有点的最短
template ＜ class T＞ ，map和vector用法——恶补c++
出尘的博客
04-28 1093
部分目录template < class T> 是什么找到各素数因子map数组下用法map遍历map元素的默认值vector 用法 template < class T> 是什么 template < class T> 是什么 即任意的数据类型，这里可以ll代替吧 但是要T相同，我不得不写了（（ll)1，n-1） 找到各素数因子 根据该函数功能，若返回它本身，即Miller_Rabin判断素数 就让该因子的map ++ 用STL里的map map数组下用法 来自https
CodeWarrior 10.x 教程：经典项目迁移到Eclipse环境
“codewarrior 10.7 import legacy project.pdf”是一份详细说明如何在基于Eclipse的CodeWarrior 10.x IDE中导入老版本CodeWarrior开发项目的应用笔记。文档涵盖两种手动移植方法，并特别关注了从CW6.3、ColdFire v...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值