首页 > 编程语言 >2023年蓝桥杯软件类省赛 C/C++ B组 解析

2023年蓝桥杯软件类省赛 C/C++ B组 解析

时间：2023-04-08 13:58:00浏览次数：44  
标签：dep fa 类省赛 rep C++ 蓝桥 int define dis

还有一题忘了题意是什么了，等拿到题面了再更

中间的题目顺序也忘了，填空题的数据也暂时还没有，暂时只有简单的思路，包括后面大题数据范围和是否多组都有点记不清

A

将题面序列处理成数组放代码里

直接枚举八个位置的 \(O(n^8)\) 复杂度对于 \(n=100\) 的范围显然本地跑也跑不出来

但由于年份限制在 2023 年内，那么就找到所有为 2023 的子序列中，3 出现的最早的位置，记作 \(p\)

那么接下来花 \(O(n^4)\) 的时间枚举月份与日期所在位置，判断下即可

重复日期只算一次，故使用 set 去重

#include<bits/stdc++.h>
#define rep(i,a,b) for(int i=(a);i<=(b);i++)
#define repp(i,a,b) for(int i=(a);i<(b);i++)
#define per(i,a,b) for(int i=(a);i>=(b);i--)
#define pb push_back
using namespace std;

int a[100]={/* 数列是啥 */};
int cnt[13]={0,31,28,31,30,31,30,31,31,30,31,30,31};

int main()
{
    int flag=0,p;
    repp(i,0,100)
    {
        if(flag==0&&a[i]==2)flag++;
        else if(flag==1&&a[i]==0)flag++;
        else if(flag==2&&a[i]==2)flag++;
        else if(flag==3&&a[i]==3)flag++;
        if(flag==4)
        {
            p=i;
            break;
        }
    }
    set<int> st;
    repp(x,p+1,100)
        repp(y,x+1,100)
            repp(z,y+1,100)
                repp(u,z+1,100)
                {
                    int m=a[x]*10+a[y];
                    int d=a[z]*10+a[u];
                    if(m>=1&&m<=12&&d>=1&&d<=cnt[m])
                        st.insert(m*100+d);
                }
    cout<<st.size()<<'\n';
    return 0;
}

B

根据题意，\(p(0)\) 表示字符 0 在整个字符串中数量的占比，同理 \(p(1)\) 表示字符 1 在整个字符串中数量的占比

由于两者与字符串实际上长什么样并没有关系，我们只需要知道字符串总长以及两种字符各自的数量即可

记 \(cnt_0\) 表示 0 的总数，\(cnt_1\) 表示 1 的总数，且 \(cnt_0+cnt_1=total=23333333\)

根据式子，总共有 \(cnt_0\) 项对熵的贡献是 \(-p(0)\log_2p(0)\)，总共有 \(cnt_1=total-cnt_0\) 项对熵的贡献是 \(-p(1)\log_2p(1)\)

换句话说，熵就是 \(-cnt_0\cdot p(0)\log_2p(0)-cnt_1\cdot p(1)\log_2p(1)\)

枚举 \(cnt_0\) 从 \(0\) 到 \(\lfloor\frac{total}2\rfloor\)，检查哪一项的值符合条件即可

时间复杂度 \(O(n)\)

#include<bits/stdc++.h>
#define rep(i,a,b) for(int i=(a);i<=(b);i++)
#define repp(i,a,b) for(int i=(a);i<(b);i++)
#define per(i,a,b) for(int i=(a);i>=(b);i--)
#define pb push_back
using namespace std;

int main()
{
    const double ans = 0.0; // 答案是啥
    int total=23333333;
    rep(i,0,total/2)
    {
        double c0=1.0*i/total;
        double c1=1.0*(total-i)/total;
        double s=-i*c0*log2(c0)-(total-i)*c1*log2(c1);
        if(fabs(s-ans)<1e-4)
            cout<<i<<'\n';
    }
    return 0;
}

接龙

我们可以预先处理出第 \(i\) 个数的首位 \(L_i\) 及末位 \(R_i\)，可以读入成字符串处理，也可以通过数位处理

考虑动态规划，记 \(dp[i]\) 表示在取第 \(i\) 个数当作接龙的最后一个数的前提下，第 \(1\) 个数到第 \(i\) 个数当中最长的接龙长度是多少

那么只需要按顺序处理，记一下 \(last[j]\) 表示最后一次出现末位为 \(j\) 的那个数在什么位置

转移方程便是 \(dp[i] = dp[last[L_i]] + 1\)

转移完成后更新一下 \(last[R_i]=i\) 即可

最后找一遍 \(dp\) 数组，取最大的值，答案便是 \(n-\max(\{dp\})\)

时间复杂度 \(O(n\log_{10} a_i)\)

#include<bits/stdc++.h>
#define rep(i,a,b) for(int i=(a);i<=(b);i++)
#define repp(i,a,b) for(int i=(a);i<(b);i++)
#define per(i,a,b) for(int i=(a);i>=(b);i--)
#define pb push_back
using namespace std;

int n;
int L[100050],R[100050];
int dp[100050];
int last[100050];

void solve()
{
    cin>>n;
    rep(i,1,n)
    {
        int d; cin>>d;
        R[i]=d%10;
        while(d>9)
            d/=10;
        L[i]=d;
    }
    int mx=0;
    rep(i,1,n)
    {
        dp[i]=dp[last[L[i]]]+1;
        mx=max(mx,dp[i]);
        last[R[i]]=i;
    }
    cout<<n-mx<<'\n';
}

int main()
{
    ios::sync_with_stdio(0);
    cin.tie(0);cout.tie(0);
    solve();
    return 0;
}

金属

假设答案为 \(k\)，如果能用 \(a\) 份原料最多造出来 \(b\) 份成品，则应当满足：

  • \(bk\le a \lt (b+1)k\)

对于左侧，移项得 \(k \le \frac a b\)，可向下取整，得右边界为 \(\lfloor \frac a b \rfloor\)

对于右侧，移项得 \(k\gt \frac a {b+1}\)，在 \(a\) 不是 \(b+1\) 的倍数的情况下应当向上取整，而在 \(a\) 是 \(b+1\) 倍数的倍数的情况下应当 \(+1\)，得左边界为 \(\lfloor \frac a {b+1} \rfloor + 1\)

因此对于每条记录 \((a,b)\)，可以得出答案区间为 \(\lfloor \frac a {b+1} \rfloor + 1 \sim \lfloor \frac a b \rfloor\)

对于多条记录，区间求交即可

时间复杂度 \(O(n)\)

#include<bits/stdc++.h>
#define rep(i,a,b) for(int i=(a);i<=(b);i++)
#define repp(i,a,b) for(int i=(a);i<(b);i++)
#define per(i,a,b) for(int i=(a);i>=(b);i--)
#define pb push_back
using namespace std;

void solve()
{
    int n;
    cin>>n;
    int mn=-1,mx=2e9;
    rep(i,1,n)
    {
        int a,b;
        cin>>a>>b;
        mn=max(mn,a/(b+1)+1);
        mx=min(mx,a/b);
    }
    cout<<mn<<' '<<mx<<'\n';
}

int main()
{
    ios::sync_with_stdio(0);
    cin.tie(0);cout.tie(0);
    solve();
    return 0;
}

飞机

发现 \(n=10\)，考虑直接使用 next_permutation 或者 dfs 枚举所有可能的顺序即可

检查过程中，即上一架飞机降落后的时间为 \(mx\)，则下一架飞机能够成功降落的条件为 \(mx\le T_i+D_i\)，降落后的时间应当是 \(\max(mx,T_i)+L_i\)

时间复杂度 \(O(T\times n!)\)

#include<bits/stdc++.h>
#define rep(i,a,b) for(int i=(a);i<=(b);i++)
#define repp(i,a,b) for(int i=(a);i<(b);i++)
#define per(i,a,b) for(int i=(a);i>=(b);i--)
#define pb push_back
using namespace std;
typedef long long ll;
typedef pair<int,int> pii;

int n,T[15],D[15],L[15];
int ord[15];

void solve()
{
    cin>>n;
    rep(i,1,n)
        cin>>T[i]>>D[i]>>L[i];
    repp(i,0,n)
        ord[i]=i+1;
    do
    {
        int mx=0;
        bool flag=true;
        repp(i,0,n)
        {
            if(mx>T[ord[i]]+D[ord[i]])
            {
                flag=false;
                break;
            }
            mx=max(mx,T[ord[i]]+L[ord[i]]);
        }
        if(flag)
        {
            cout<<"YES\n";
            return;
        }
    }while(next_permutation(ord,ord+n));
    cout<<"NO\n";
}

int main()
{
    ios::sync_with_stdio(0);
    cin.tie(0);cout.tie(0);
    int T; cin>>T; while(T--)
        solve();
    return 0;
}

岛屿

明显，通过搜索的方式实现找环、判点在环内太麻烦了

由于如果某个岛屿 \(b\) 完全包含在岛屿 \(a\) 内，那么 \(b\) 是不会统计到答案里的

因此我们只需要找有多少个岛屿能够接触到最外层的海水即可

不妨将整张图往外扩张一格，让最外层填充满海水，从最外层开始搜索，那么能够从海水中一步到达的岛屿一定是最外层的那些岛屿

需要注意的是，岛屿的环的判定是只有上下左右四个方向，样例中也能看出，例如下图是一个完整的环，内部的海水是不能被搜索的：

00000
01110
01010
01110
00000

而下图不是一格完整的环，内部的海水是能被搜索到的，因此内部岛屿需要统计在答案中：

00000
00110
01010
01110
00000

根据上面两个例子不难发现，我们在搜索海水的时候，是可以往八个方向搜的（即包含对角）

最后搜索出一些一定是外层岛屿上的位置后，遍历整张图再跑几遍搜索，找出总共有多少个连通块即可

时间复杂度 \(O(Tnm)\)

#include<bits/stdc++.h>
#define rep(i,a,b) for(int i=(a);i<=(b);i++)
#define repp(i,a,b) for(int i=(a);i<(b);i++)
#define per(i,a,b) for(int i=(a);i>=(b);i--)
#define pb push_back
using namespace std;
typedef pair<int,int> pii;

const int dx[8]={0,1,0,-1,-1,-1,1,1},dy[8]={1,0,-1,0,-1,1,-1,1};

int n,m;
char mp[55][55];
bool vis[55][55];
bool island[55][55];

inline bool prim(int x,int y)
{
    return x>=0&&y>=0&&x<=n+1&&y<=m+1;
}

void bfs(int sx,int sy)
{
    queue<pii> q;
    q.push(pii(sx,sy));
    vis[sx][sy]=true;
    while(!q.empty())
    {
        pii p=q.front();
        q.pop();
        int x=p.first,y=p.second;
        repp(i,0,4) // 四个方向
        {
            int px=x+dx[i],py=y+dy[i];
            if(prim(px,py))
            {
                if(mp[px][py]=='1'&&!vis[px][py])
                {
                    vis[px][py]=true;
                    q.push(pii(px,py));
                }
            }
        }
    }
}

void solve()
{
    cin>>n>>m;
    rep(i,1,n)
        cin>>(mp[i]+1);
    rep(i,0,n+1)
        rep(j,0,m+1)
            vis[i][j]=island[i][j]=false;
    
    // 周围填海水
    rep(i,0,n+1)
        mp[i][0]=mp[i][m+1]='0';
    rep(j,0,m+1)
        mp[0][j]=mp[n+1][j]='0';
    
    // 搜海水
    queue<pii> q;
    q.push(pii(0,0));
    vis[0][0]=true;
    while(!q.empty())
    {
        pii p=q.front();
        q.pop();
        int x=p.first,y=p.second;
        repp(i,0,8) // 八个方向
        {
            int px=x+dx[i],py=y+dy[i];
            if(prim(px,py))
            {
                if(mp[px][py]=='0')
                {
                    if(!vis[px][py])
                    {
                        vis[px][py]=true;
                        q.push(pii(px,py));
                    }
                }
                else
                    island[px][py]=true;
            }
        }
    }
    
    // 搜岛屿
    rep(i,0,n+1)
        rep(j,0,m+1)
            vis[i][j]=false;
    int ans=0;
    rep(i,1,n)
        rep(j,1,m)
            if(island[i][j]&&!vis[i][j]) // 如果是没有搜索过的外层岛屿
            {
                bfs(i,j);
                ans++;
            }
    cout<<ans<<'\n';
}

int main()
{
    ios::sync_with_stdio(0);
    cin.tie(0);cout.tie(0);
    int T; cin>>T; while(T--)
        solve();
    return 0;
}

缩写

直接遍历，在遇到字符 \(b\) 时统计下 \(1\sim i-k+1\) 内有多少个字符 \(a\)，加入答案即可

统计方面，遇到字符 \(a\) 时存下当前位置，只需二分找出最后一个符合条件的位置即可

时间复杂度 \(O(n\log n)\)

#include<bits/stdc++.h>
#define rep(i,a,b) for(int i=(a);i<=(b);i++)
#define repp(i,a,b) for(int i=(a);i<(b);i++)
#define per(i,a,b) for(int i=(a);i>=(b);i--)
#define pb push_back
using namespace std;
typedef long long ll;
typedef pair<int,int> pii;

void solve()
{
    int k;
    string s;
    char a,b;
    cin>>k>>s>>a>>b;
    vector<int> vec;
    ll ans=0;
    repp(i,0,s.size())
    {
        if(s[i]==b)
            ans+=upper_bound(vec.begin(),vec.end(),i-k+1)-vec.begin();
        if(s[i]==a)
            vec.pb(i);
    }
    cout<<ans<<'\n';
}

int main()
{
    ios::sync_with_stdio(0);
    cin.tie(0);cout.tie(0);
    solve();
    return 0;
}

I

首先，对于每对 \((A_i,A_{i+1})\) 通过搜索将最短路找出来，在 \(n=k=10^5\) 的数据范围下是不现实的

但发现给定的图是一棵树，假如可以确定树根 \(rt\)，那么树上两点 \((a,b)\) 之间距离也就等于 \(a\) 到 \(rt\) 的距离加上 \(b\) 到树根的距离减去两倍 \(lca(a,b)\) 到树根的距离，这里的 \(lca(a,b)\) 表示 \(a\) 与 \(b\) 两点的最近公共祖先

通过倍增的方法，可以在 \(O(\log n)\) 的时间复杂度内求出两点的 \(lca\)

因此我们可以计算得到按照 \(A_1,A_2,\cdots,A_k\) 的顺序走时的总距离 \(sum\)

但根据题意，对于 \(i=1\sim k\) 都需要求一遍当去除 \(A_i\) 这个点时的答案是多少，于是分以下三种情况讨论：

  • \(i=1\)，则从 \(sum\) 中减去 \(A_1\) 走到 \(A_2\) 的贡献；
  • \(i=k\)，则从 \(sum\) 中减去 \(A_{k-1}\) 走到 \(A_k\) 的贡献；
  • \(i\in[2,k-1]\)，则先从 \(sum\) 中减去 \(A_{i-1}\) 走到 \(A_i\) 的贡献，再减去 \(A_{i}\) 走到 \(A_{i+1}\) 的贡献，最后加上 \(A_{i-1}\) 走到 \(A_{i+1}\) 的贡献。

时间复杂度 \(O(n\log n)\)

#include<bits/stdc++.h>
#define rep(i,a,b) for(int i=(a);i<=(b);i++)
#define repp(i,a,b) for(int i=(a);i<(b);i++)
#define per(i,a,b) for(int i=(a);i>=(b);i--)
#define pb push_back
using namespace std;
typedef long long ll;
typedef pair<int,int> pii;

int n,k;
vector<pii> G[100050];
int A[100050],LCA[100050];
int dep[100050];
int fa[100050][18];
ll dis[100050];

void dfs(int u,int f)
{
    fa[u][0]=f;
    rep(i,1,17)
        fa[u][i]=fa[fa[u][i-1]][i-1];
    for(pii &p:G[u])
    {
        int &v=p.first,&w=p.second;
        if(v==f)
            continue;
        dep[v]=dep[u]+1;
        dis[v]=dis[u]+w;
        dfs(v,u);
    }
}

int lca(int a,int b)
{
    while(dep[a]>dep[b])
    {
        per(i,17,0)
            if(dep[a]-(1<<i)>=dep[b])
                a=fa[a][i];
    }
    while(dep[a]<dep[b])
    {
        per(i,17,0)
            if(dep[b]-(1<<i)>=dep[a])
                b=fa[b][i];
    }
    if(a==b)
        return a;
    while(fa[a][0]!=fa[b][0])
    {
        per(i,17,0)
            if(fa[a][i]!=fa[b][i])
            {
                a=fa[a][i];
                b=fa[b][i];
            }
    }
    return fa[a][0];
}

void solve()
{
    cin>>n>>k;
    repp(i,1,n)
    {
        int a,b,w;
        cin>>a>>b>>w;
        G[a].pb(pii(b,w));
        G[b].pb(pii(a,w));
    }
    rep(i,1,k)
        cin>>A[i];
    dfs(1,0);
    rep(i,2,k)
        LCA[i]=lca(A[i-1],A[i]);
    ll sum=0;
    rep(i,2,k)
        sum+=dis[A[i-1]]+dis[A[i]]-2*dis[LCA[i]];
    rep(i,1,k)
    {
        ll tmp=sum;
        if(i==1)
            tmp-=dis[A[1]]+dis[A[2]]-2*dis[LCA[2]];
        else if(i==k)
            tmp-=dis[A[k-1]]+dis[A[k]]-2*dis[LCA[k]];
        else
        {
            tmp-=dis[A[i-1]]+dis[A[i]]-2*dis[LCA[i]];
            tmp-=dis[A[i]]+dis[A[i+1]]-2*dis[LCA[i+1]];
            tmp+=dis[A[i-1]]+dis[A[i+1]]-2*dis[lca(A[i-1],A[i+1])];
        }
        cout<<tmp<<(i==k?'\n':' ');
    }
}

int main()
{
    ios::sync_with_stdio(0);
    cin.tie(0);cout.tie(0);
    solve();
    return 0;
}

J

可以将题意转换成，对于所有的 \(m\) 对给定的点对 \((a,b)\)，如果都从 \(a\) 走到 \(b\)，哪条边被走过了 \(m\) 次，多条边则取编号最大的一条

但本题统计的是边走过的次数，因此将边权转化为点权，以 \(1\) 为根时，其它所有点的点权都代表着连接自己与父亲的那条边走过的次数

对于从 \(a\) 走到 \(b\) 的路径上的标记，考虑采用树上差分，在 \(a\) 所在位置 \(+1\)，在 \(b\) 所在位置 \(+1\)，在 \(lca(a,b)\) 所在位置 \(-2\)，最后从叶子向树根求和来算出每个点的点权，这里的 \(lca(a,b)\) 表示 \(a\) 与 \(b\) 两点的最近公共祖先，通过倍增实现

搜索时记录下每条边的编号是多少，把点权加到那个编号上，最后倒序找一遍那条边经过次数 \(=m\) 即可

时间复杂度 \(O(n\log n)\)

#include<bits/stdc++.h>
#define rep(i,a,b) for(int i=(a);i<=(b);i++)
#define repp(i,a,b) for(int i=(a);i<(b);i++)
#define per(i,a,b) for(int i=(a);i>=(b);i--)
#define pb push_back
using namespace std;
typedef long long ll;
typedef pair<int,int> pii;

int n,m;
vector<pii> G[100050];
int dep[100050];
int fa[100050][18];
int cha[100050];
int ans[100050];

void dfs(int u,int f)
{
    fa[u][0]=f;
    rep(i,1,17)
        fa[u][i]=fa[fa[u][i-1]][i-1];
    for(pii &p:G[u])
    {
        int &v=p.first,&w=p.second;
        if(v==f)
            continue;
        dep[v]=dep[u]+1;
        dfs(v,u);
    }
}

int lca(int a,int b)
{
    while(dep[a]>dep[b])
    {
        per(i,17,0)
            if(dep[a]-(1<<i)>=dep[b])
                a=fa[a][i];
    }
    while(dep[a]<dep[b])
    {
        per(i,17,0)
            if(dep[b]-(1<<i)>=dep[a])
                b=fa[b][i];
    }
    if(a==b)
        return a;
    while(fa[a][0]!=fa[b][0])
    {
        per(i,17,0)
            if(fa[a][i]!=fa[b][i])
            {
                a=fa[a][i];
                b=fa[b][i];
            }
    }
    return fa[a][0];
}

void dfs2(int u,int f)
{
    for(pii &p:G[u])
    {
        int &v=p.first,&id=p.second;
        if(v==f)
            continue;
        dfs2(v,u); // 子树搜索完后再往上传，处理答案
        cha[u]+=cha[v];
        ans[id]=cha[v];
    }
}

void solve()
{
    cin>>n>>m;
    repp(i,1,n)
    {
        int a,b;
        cin>>a>>b;
        G[a].pb(pii(b,i));
        G[b].pb(pii(a,i));
    }
    dfs(1,0);
    rep(i,1,m)
    {
        int a,b;
        cin>>a>>b;
        cha[a]++;
        cha[b]++;
        cha[lca(a,b)]-=2;
    }
    dfs2(1,0);
    per(i,n-1,1)
    {
        if(ans[i]==m)
        {
            cout<<i<<'\n';
            return;
        }
    }
}

int main()
{
    ios::sync_with_stdio(0);
    cin.tie(0);cout.tie(0);
    solve();
    return 0;
}

标签：dep,fa,类省赛,rep,C++,蓝桥,int,define,dis
From： https://www.cnblogs.com/stelayuri/p/17298408.html

相关文章

  • 蓝桥杯 2022 省 B
    C-刷题统计https://www.luogu.com.cn/problem/P8780签到题，先大跨步对每周的题数取模，然后暴力计算最后一周需要做的题。intmain(){ i64a=read(),b=read(),n=read(); i64ans=n/(5*a+2*b)*7,rest=n%(5*a+2*b); for(inti=1;i<=5;i......
  • CMU_15_445_project_0_C++_Primer
    CMU15_445project_0C++Primertask1Copy-On-WriteTrieGetGet比较简单,遍历字符串和trie,找得到就返回值,找不到就返回nullptr.Put每个树有一个没有value的根节点,节点的类型分为TrieNode类和TrieNodeWithValue类,TrieNode是基类不存value,TrieNodeWithValue类继......
  • C++笔记（一）
    C++笔记（一）反复考量之后，还是决定将C++作为我的第二语言以及以后的主力开发语言。目录C++笔记（一）语法基础基本数据类型变量、常量作用域基本运算补码字节序基本结构顺序结构分支结构循环结构指针内存空间动态分配内存二级指针空指针野指针函数指针常见容器类型数组语法基础基本数......
  • C++竞赛常用函数库stl快捷查询手册（vector,map,set,queue,string等）
    1.控制输出流<iomanip>;cout<<setprecision(<span="">int);保留int位有效数字cout<<setprecision(<span="">int)<<fixed;保留int位有效小数为不足4位数的数填充0(如1填充变成0001）,cout<<setfill('0')<<setw(4)(一次性效果）......
  • 回调函数 C++
    回调函数（CallbackFunction）是一种常见的编程模式，它是一段可以被传递给其他函数的代码，可以在特定的条件满足时被调用执行。回调函数通常作为参数传递给其他函数，以便在某些事件发生时执行。在C++中，回调函数通常是一个指向函数的指针，它可以作为参数传递给其他函数，这些函数可以在需要......
  • C/C++模拟ATM机存取款管理系统[2023-04-07]
    C/C++模拟ATM机存取款管理系统[2023-04-07]2、模拟ATM机存取款管理系统模拟银行的自动取款机使用过程中的界面和用户交互过程。实现查询银行卡余额、取款修改密码、退出系统等功能。(一)功能要求及说明:(1)将银行账户的卡号，户名，密码和账户余额从外部文件(银行账户.txt)中读入......
  • 蓝桥考试技巧
    蓝桥考试技巧256M预留一些堆外空间后大概剩200M考心态，多看几个题，每个题目都看看打表能写出来一个大概的算法就先写上回来再想一些特殊点、注意LL问题押题枚举进位制双指针算法前缀和二分区间DP（记忆化搜索）背包问题（有限制的选择最优化问题）（01，完......
  • 蓝桥-13届-青蛙过河
    看完没什么思路就类似于看完一个自然语言描述的问题后，没法把它转换编程模型题目的意思是y至少要多大，才能足够青蛙跳2x次因为跳跃过程是可逆的，于是能否往返跳2x次等价于同向跳2x次由于当y=n时，青蛙不需要踩任何石头直接跳过去，于是y一定是小于等于n的一个数照这个数我们可以使用......
  • 什么是虚拟函数 —— C++ 开发人员应该如何充分利用它？
    什么是虚拟函数？虚拟函数是基类中声明的成员函数，且使用者期望在派生类中将其重新定义。那么，在C++中，什么是虚拟函数呢？在C++中，通常将虚拟函数用于实现运行时多态，该特性由C++提供，适用于面向对象编程。我们将在下文更为详细地讨论运行时多态。不论函数调用所使用的指针或引用类型......
  • C++虚函数
    形式：virtual函数类型函数名（）（在派生类和基类里都要写）静态成员函数不能是虚函数1.通过指针实现多态对于基类的对象：调用基类的虚函数对于派生类的对象：调用派生类的虚函数#include<iostream>usingnamespacestd;classA{ public: virtualvoidPrint() { cout<<"printA"......

赞助商

阅读排行

网站主页关于我们联系我们网站地图

本网站内容转载自其他媒体，侵权联系[admin##ips99.com]。

Copyright © 2020-2023 IPS99 版权所有 IPS99