C++ Primer Plus, Chapter 13, excercise

最新推荐文章于 2024-09-12 08:56:38 发布
最新推荐文章于 2024-09-12 08:56:38 发布
阅读量306 收藏
点赞数
文章标签： c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/beautiful_landscape/article/details/72773149
版权

1.CD

//classic.h
#ifndef CLASSIC_H_
#define CLASSIC_H_
class CD
{
private:
    char performers[50];
    char label[20];
    int selections;
    double playtime;
public:
    CD(const char * s1, const char * s2, int n, double x);
    //CD(const CD & d);
    CD();
    virtual ~CD();
    virtual void Report() const;
    //CD & operator=(const CD & d);
};
class Classic :public CD
{
private:
    char main[50];
public:
    Classic(const char * m = "null", const char * s1 = "nullbody", const char * s2 = "null", int n = 0, double x = 0.0);
    Classic(const char * m, const CD & d);
    virtual void Report() const;
};
#endif

//classic.cpp
#include "stdafx.h"
#include "classic.h"
#include <iostream>

//CD
CD::CD(const char * s1, const char * s2, int n, double x)
{
    strcpy(performers, s1);
    strcpy(label, s2);
    selections = n;
    playtime = x;
}
CD::CD()
{
    strcpy(performers, "nullbody");
    strcpy(label, "null");
    selections = 0;
    playtime = 0.0;
}
CD::~CD()
{

}
void CD::Report() const
{
    std::cout << "performers: " << performers << std::endl;
    std::cout << "label: " << label << std::endl;
    std::cout << "selections: " << selections << std::endl;
    std::cout << "playtime: " << playtime << std::endl;
}

//Classic
Classic::Classic(const char * m, const char * s1, const char * s2, int n, double x) :CD(s1, s2, n, x)
{
    strcpy(main, m);
}
Classic::Classic(const char * m, const CD & d) : CD(d)
{
    strcpy(main, m);
}
void Classic::Report() const
{
    CD::Report();
    std::cout << "main: " << main << std::endl;
}

//main.cpp
#include "stdafx.h"
#include "classic.h"
#include <iostream>

void Bravo(const CD & disk);
int main()
{
    using std::cout;

    CD c1("Beatles", "Capitol", 14, 35.5);
    Classic c2 = Classic("Piano Sonata in B flat, Fantansia in C", "Alfred Brendel", "Philips", 2, 57.17);
    CD *pcd = &c1;
    cout << "Using object directly:\n";
    c1.Report();
    c2.Report();
    cout << "Using type CD * pointer to objects:\n";
    pcd->Report();
    pcd = &c2;
    pcd->Report();
    cout << "Calling a function with a CD reference argument:\n";
    Bravo(c1);
    Bravo(c2);
    cout << "Testing assignment: ";
    Classic copy;
    copy = c2;
    copy.Report();
    std::cin.get();
    return 0;
}
void Bravo(const CD & disk)
{
    disk.Report();
}

2.动态分配内存完成1

//classic.h
#ifndef CLASSIC_H_
#define CLASSIC_H_
class CD
{
private:
    char * performers;
    char * label;
    int selections;
    double playtime;
public:
    CD(const char * s1, const char * s2, int n, double x);
    CD(const CD & d);
    CD();
    virtual ~CD();
    virtual void Report() const;
    CD & operator=(const CD & d);
};
class Classic :public CD
{
private:
    char * main;
public:
    Classic(const char * m = "null", const char * s1 = "nullbody", const char * s2 = "null", int n = 0, double x = 0.0);
    Classic(const char * m, const CD & d);
    virtual void Report() const;
    Classic(const Classic & c);
    Classic & operator=(const Classic & c);
    ~Classic();
};
#endif

//classic.cpp
#include "stdafx.h"
#include "classic.h"
#include <iostream>

//CD
CD::CD(const char * s1, const char * s2, int n, double x)
{
    performers = new char[strlen(s1) + 1];
    strcpy(performers, s1);
    label = new char[strlen(s2) + 1];
    strcpy(label, s2);
    selections = n;
    playtime = x;
}
CD::CD()
{
    performers = nullptr;
    //strcpy(performers, "nullbody");
    label = nullptr;
    //strcpy(label, "null");
    selections = 0;
    playtime = 0.0;
}
CD::~CD()
{
    delete[] performers;
    delete[] label;
}
void CD::Report() const
{
    std::cout << "performers: " << performers << std::endl;
    std::cout << "label: " << label << std::endl;
    std::cout << "selections: " << selections << std::endl;
    std::cout << "playtime: " << playtime << std::endl;
}
CD::CD(const CD & d)
{
    performers = new char[strlen(d.performers) + 1];
    strcpy(performers, d.performers);
    label = new char[strlen(d.label) + 1];
    strcpy(label, d.label);
    selections = d.selections;
    playtime = d.playtime;
}
CD & CD::operator=(const CD & d)
{
    if (this == &d)
        return *this;
    else
    {
        delete[] performers;
        performers = new char[strlen(d.performers) + 1];
        strcpy(performers, d.performers);
        delete[] label;
        label = new char[strlen(d.label) + 1];
        strcpy(label, d.label);
        selections = d.selections;
        playtime = d.playtime;
        return *this;
    }

}

//Classic
Classic::Classic(const char * m, const char * s1, const char * s2, int n, double x) :CD(s1, s2, n, x)
{
    main = new char[strlen(m) + 1];
    strcpy(main, m);
}
Classic::Classic(const char * m, const CD & d) : CD(d)
{
    main = new char[strlen(m) + 1];
    strcpy(main, m);
}
void Classic::Report() const
{
    CD::Report();
    std::cout << "main: " << main << std::endl;
}
Classic::Classic(const Classic & c) :CD(c)
{
    main = new char[strlen(c.main) + 1];
    strcpy(main, c.main);
}
Classic & Classic::operator=(const Classic & c)
{
    if (this == &c)
        return *this;
    else
    {
        CD::operator=(c);
        delete[] main;
        main = new char[strlen(c.main) + 1];
        strcpy(main, c.main);
        return *this;
    }
}
Classic::~Classic()
{
    delete[] main;
}

//main.cpp
#include "stdafx.h"
#include "classic.h"
#include <iostream>

void Bravo(const CD & disk);
int main()
{
    using std::cout;

    CD c1("Beatles", "Capitol", 14, 35.5);
    Classic c2 = Classic("Piano Sonata in B flat, Fantansia in C", "Alfred Brendel", "Philips", 2, 57.17);
    CD *pcd = &c1;
    cout << "Using object directly:\n";
    c1.Report();
    c2.Report();
    cout << "Using type CD * pointer to objects:\n";
    pcd->Report();
    pcd = &c2;
    pcd->Report();
    cout << "Calling a function with a CD reference argument:\n";
    Bravo(c1);
    Bravo(c2);
    cout << "Testing assignment: ";
    Classic copy;
    copy = c2;
    copy.Report();
    std::cin.get();
    return 0;
}
void Bravo(const CD & disk)
{
    disk.Report();
}

3.三个DMA由ABC派生

//dma.h
#ifndef DMA_H_
#define DMA_H_
#include <iostream>
class DMA
{
private:
    char * label;
    int rating;
public:
    DMA(const char * l = "null", int r = 0);
    DMA(const DMA & rs);
    virtual ~DMA();
    DMA & operator=(const DMA & rs); //不是共有的，不能用作纯虚函数
    //friend std::ostream & operator<<(std::ostream & os, const DMA & rs);
    virtual void View() const = 0;
};
class baseDMA :public DMA
{
public:
    baseDMA(const char * l = "null", int r = 0);
    //friend std::ostream & operator<<(std::ostream & os, const baseDMA & bs);
    virtual void View() const;
};
class lacksDMA :public DMA
{
private:
    enum{ COL_LEN = 40 };
    char color[COL_LEN];
public:
    lacksDMA(const char * c = "black", const char * l = "null", int r = 0);
    lacksDMA(const char * c, const DMA & rs);
    //friend std::ostream & operator<<(std::ostream & os, const lacksDMA & ls);
    virtual void View() const;
};
class hasDMA :public DMA
{
private:
    char * style;
public:
    hasDMA(const char * s = "none", const char * l = "null", int r = 0);
    hasDMA(const char * s, const DMA & rs);
    hasDMA(const hasDMA & hs);
    ~hasDMA();
    virtual hasDMA & operator=(const hasDMA & hs);
    //friend std::ostream & operator<<(std::ostream & os, const hasDMA & hs);
    virtual void View() const;
};
#endif

//dma.cpp
#include "stdafx.h"
#include "dma.h"

//DMA
DMA::DMA(const char * l, int r)
{
    label = new char[strlen(l) + 1];
    strcpy(label, l);
    rating = r;
}
DMA::DMA(const DMA & rs)
{
    label = new char[strlen(rs.label) + 1];
    strcpy(label, rs.label);
    rating = rs.rating;
}
DMA::~DMA()
{
    delete[] label;
}
DMA & DMA::operator=(const DMA & rs)
{
    if (this == &rs)
        return *this;
    else
    {
        delete[] label;
        label = new char[strlen(rs.label) + 1];
        strcpy(label, rs.label);
        rating = rs.rating;
        return *this;
    }
}
void DMA::View() const
{
    std::cout << "label: " << label << std::endl;
    std::cout << "rating: " << rating << std::endl;
}
/*std::ostream & operator<<(std::ostream & os, const DMA & rs)
{
    os << "label: " << rs.label << std::endl;
    os << "rating: " << rs.rating << std::endl;
    return os;
}*/

//baseDMA
baseDMA::baseDMA(const char * l, int r) :DMA(l, r)
{

}
void baseDMA::View() const
{
    DMA::View();
}
/*std::ostream & operator<<(std::ostream & os, const baseDMA & bs)
{
    os << (const DMA &)bs;
    return os;
}*/


//lacksDMA
lacksDMA::lacksDMA(const char * c, const char * l, int r) :DMA(l, r)
{
    strcpy(color, c);
}
lacksDMA::lacksDMA(const char * c, const DMA & rs) : DMA(rs)
{
    strcpy(color, c);
}
void lacksDMA::View() const
{
    DMA::View();
    std::cout << "color: " << color << std::endl;
}
/*std::ostream & operator<<(std::ostream & os, const lacksDMA & ls)
{
    os << (const DMA &)ls; //输出baseDMA的
    os << "color: " << ls.color << std::endl;
    return os;
}*/

//hasDMA
hasDMA::hasDMA(const char * s, const char * l, int r) :DMA(l, r)
{
    style = new char[strlen(s) + 1];
    strcpy(style, s);
}
hasDMA::hasDMA(const char * s, const DMA & rs) : DMA(rs)
{
    style = new char[strlen(s) + 1];
    strcpy(style, s);
}
hasDMA::hasDMA(const hasDMA & hs) : DMA(hs)
{
    style = new char[strlen(hs.style) + 1];
    strcpy(style, hs.style);
}
hasDMA::~hasDMA()
{
    delete[] style;
}
hasDMA & hasDMA::operator=(const hasDMA & hs)
{
    if (this == &hs)
        return *this;
    else
    {
        DMA::operator=(hs); //赋值DMA的
        delete[] style;
        style = new char[strlen(hs.style) + 1];
        strcpy(style, hs.style);
        return *this;
    }
}
void hasDMA::View() const
{
    DMA::View();
    std::cout << "style: " << style << std::endl;
}
/*std::ostream & operator<<(std::ostream & os, const hasDMA & hs)
{
    os << (const DMA &)hs;
    os << "style: " << hs.style << std::endl;
    return os;
}*/

//main.cpp
#include "stdafx.h"
#include "dma.h"
#include <ctime>
#include <string>

const int CLIENT = 4;
int main()
{
    using std::cout;
    using std::cin;
    using std::endl;

    DMA * p_clients[CLIENT];
    char lb[50]; //不能用string， string 不能转为char
    int rt;
    char kind;
    for (int i = 0; i < CLIENT; i++)
    {
        cout << "Enter label: ";
        cin.getline(lb, 50);
        cout << "Enter rating: ";
        cin >> rt;
        while (cin.get() != '\n') //读取换行符有时候要有时候不要
            continue;
        cout << "Enter 1 for baseDMA, 2 for lacksDMA or 3 for hasDMA: ";
        while (cin >> kind && kind != '1' && kind != '2' && kind != '3')
        {
            cout << "Enter 1, 2 or 3: ";
        }
        while (cin.get() != '\n')
            continue;
        if (kind == '1')
            p_clients[i] = new baseDMA(lb, rt);
        else if (kind == '2')
        {
            char cl[50];
            cout << "Enter color: ";
            cin.getline(cl, 50);
            p_clients[i] = new lacksDMA(cl, lb, rt);
        }
        else
        {
            char st[50];
            cout << "Enter style: ";
            cin.getline(st, 50);
            p_clients[i] = new hasDMA(st, lb, rt);
        }
    }
    cout << endl;
    for (int i = 0; i < CLIENT; i++)
    {
        p_clients[i]->View();
        cout << endl;
    }
    for (int i = 0; i < CLIENT; i++)
        delete p_clients[i];
    cout << "Done!\n";


    clock_t delay = 100 * CLOCKS_PER_SEC;
    clock_t start = clock();
    while (clock() - start < delay)
        ;
}

4.葡萄酒类

//port.h
#ifndef PORT_H_
#define PORT_H_
#include <iostream>
using namespace std;
class Port
{
private:
    char * brand;
    char style[20];
    int bottles;
public:
    Port(const char * br = "none", const char * st = "none", int b = 0);
    Port(const Port & p);
    virtual ~Port() { delete[] brand; }
    Port & operator=(const Port & p);
    Port & operator+=(int b);
    Port & operator-=(int b);
    int BottleCount() const { return bottles; }
    virtual void Show() const;
    friend ostream & operator<<(ostream & os, const Port & p);
};
class VintagePort :public Port
{
private:
    char *nickname;
    int year;
public:
    VintagePort(const char * br, const char * st, int b, const char * nn, int y);
    VintagePort(const VintagePort & vp);
    ~VintagePort() { delete[] nickname; }
    VintagePort & operator=(const VintagePort & vp);
    void Show() const;
    friend ostream & operator<<(ostream & os, const VintagePort & vp);
};
#endif

//port.cpp
#include "stdafx.h"
#include "port.h"

//Port
Port::Port(const char * br, const char * st, int b)
{
    brand = new char[strlen(br) + 1];
    strcpy(brand, br);
    strcpy(style, st);
    bottles = b;
}
Port::Port(const Port & p)
{
    brand = new char[strlen(p.brand) + 1];
    strcpy(brand, p.brand);
    strcpy(style, p.style);
    bottles = p.bottles;
}
Port & Port::operator=(const Port & p)
{
    if (this == &p)
        return *this;
    else
    {
        delete[] brand;
        brand = new char[strlen(p.brand) + 1];
        strcpy(brand, p.brand);
        strcpy(style, p.style);
        bottles = p.bottles;
        return *this;
    }
}
Port & Port::operator+=(int b)
{
    this->bottles += b;
    return *this;
}
Port & Port::operator-=(int b)
{
    this->bottles -= b;
    return *this;
}
void Port::Show() const
{
    cout << "Brand: " << brand << endl;
    cout << "Kind: " << style << endl;
    cout << "Bottles: " << bottles << endl;
}
ostream & operator<<(ostream & os, const Port & p)
{
    os << p.brand << ", " << p.style << ", " << p.bottles;
    return os;
}

//VintagePort
VintagePort::VintagePort(const char * br, const char * st, int b, const char * nn, int y) :Port(br, st, b)
{
    nickname = new char[strlen(nn) + 1];
    strcpy(nickname, nn);
    year = y;
}
VintagePort::VintagePort(const VintagePort & vp) :Port(vp)
{
    nickname = new char[strlen(vp.nickname) + 1];
    strcpy(nickname, vp.nickname);
    year = vp.year;
}
VintagePort & VintagePort::operator=(const VintagePort & vp)
{
    if (this == &vp)
        return *this;
    else
    {
        Port::operator=(vp);
        delete[] nickname;
        nickname = new char[strlen(vp.nickname) + 1];
        strcpy(nickname, vp.nickname);
        year = vp.year;
        return *this;
    }
}
void VintagePort::Show() const
{
    Port::Show();
    cout << "nickname: " << nickname << endl;
    cout << "year: " << year << endl;
}
ostream & operator<<(ostream & os, const VintagePort & vp)
{
    os << (const Port &)vp;
    os << ", " << vp.nickname << ", " << vp.year;
    return os;
}

//main.cpp
#include "stdafx.h"
#include "port.h"

int main()
{
    Port p("WLJ", "hong", 20);
    VintagePort vp("MZ", "hei", 30, "maoz", 1987);
    cout << "p:\n";
    p.Show();
    cout << endl;
    cout << p << endl;
    cout << "vp:\n";
    vp.Show();
    cout << endl << vp << endl;

    cout << "p += 20: ";
    p += 20;
    p.Show();
    cout << "\nvp -= 20: ";
    vp -= 20;
    vp.Show();

    cout << endl << "copy constructor: \n";
    Port p1(p);
    p1.Show();
    cout << "fu zhi yun suan fu:\n";
    VintagePort vp2 = vp;
    vp2.Show();

    cin.get();
    return 0;
}
beautiful_landscape
关注
C++ Primer Plus 电子书PDF分享
AlgoWizard的博客
07-11 1044
Stephen本人或他人合作编写的图书有十多本。全书分17章和10个附录，分别介绍了C++程序的运行方式、基本数据类型、复合数据类型、循环和关系表达式、分支语句和逻辑操作符、函数重载和函数模板、内存模型和名称空间、类的设计和使用、多态、虚函数、动态内存分配、继承、代码重用、友元、异常处理技术、string类和标准模板库、输入/输出等内容。前4版在美国的总销售量超过了10万册。本书是根据2003年的ISO/ANSI C++标准编写的，通过大量短小精悍的程序详细而全面地阐述了C++的基本概念和技术。
C++primer plus习题+答案
yj
05-16 1676
这两条语句并不真正等价，虽然对于某些系统来说，它们是等效的。最重要的是，只有在使用ASCII码的系统上，第一条语句才将grade设置为字符A，而第二条语句还可以用于使用其他编码的系统。因为最大的long值为20亿，即有10位数。longlong类型可提供19位有效数字，超过了double保证的13位有效数字。有多种整型类型，可以根据特定需求选择最适合的类型。例如，可以使用short来存储空格，使用long来确保存储容量，也可以寻找可提高特定计算的速度的类型。33L的类型为long，常量33的类型为int。
C语言字符串char *和char[]——摘自《C primer plus》
03-15 2854
Defining Strings Within a Program As you probably noticed when you read Listing 11.1, there are many ways to define a string. The principal ways are using string constants, using char arrays, usi
C++ Primer Plus, Sixth Edition - 下载电子书与源代码
既然选择了远方 便只顾风雨兼程 - 永强
03-04 5842
C++ Primer Plus, Sixth Edition - 下载电子书与源代码
《C++ Primer Plus》（第6版）中文版
ProgramNovice的博客
04-25 2865
《C++ Primer Plus》（第6版）中文版
C++primer plus 习题+答案
yj
05-22 2744
解释：一般来说，调用一个函数流程为：当前调用命令的地址被保存下来，程序将跳转到所调用的函数并执行该函数，最后跳转回之前所保存的命令地址。对于经常需要调用的小函数来说，这大大降低了程序运行效率。所以，新增了内联函数。关键字inline告诉编译器，任何地方只要调用内联函数，就直接把函数的机器码插入到调用它的地方。这样程序执行更有效率，就好像将内联函数中的语句直接插入到了源代码文件中需要调用该函数的地方一样。适合于：只有一行代码的小型，非递归函数适合作为内联函数。
C++ primer plus
liguandong
02-10 4329
https://github.com/lilinxiong/cppPrimerPlus-six-https://github.com/lilinxiong/cppPrimerPlus-six- 最近在看C++ primer plus这本书，就顺着思路对其中的重点进行总结。在图像算法这块，cpp和python算是最核心的两种开发语言了，其实大部分时间下用的都是python，只有在比较耗时的操作上用cpp封一下so，相对来说，python要更加熟悉一下，但是日常开发中也有更加关注数据结构的优化等等。 第二章
C++primerplus习题 + 答案
yj
05-20 2140
1.使用函数的3个步骤是什么？定义函数，提供原型，调用函数。2.请创建与下面的描述匹配的函数原型d. summation()将long数组名和数组长度作为参数，并 返回一个long值e.doctor()接受一个字符串参数（不能修改该字符串），并返回一个double值f.ofcourse()将boss结构作为参数，不返回值g.plot()将map结构的指针作为参数，并返回一个字符串3.编写一个接受3个参数的函数：指向数组区间中第一个元素的指针，指向数组区间最后一个元素后面的指针以及一个int值，并将数组中的每
C++ Primer Plus书籍电子版
m0_63172128的博客
05-18 1980
学习c++,C++ Primer Plus书籍 ，这一本书就够了，下面分析一下他的电子书。pdf版本无偿分析大家一起学习，附有百度网盘链接，下载方便学习。
C++ Primer Plus 第六版 所有章节课后编程练习答案
热门推荐
xiaojimmychen的专栏
11-01 8万+
C++ Primer Plus 第六版 所有章节课后编程练习答案
C++Primer Plus附录源码等文件.zip
12-27
《C++ Primer Plus》是Stephen Prata撰写的一本广受欢迎的C++编程教材，第六版提供了深入浅出的C++语言教程，旨在帮助初学者和有一定经验的程序员掌握这一强大的编程语言。附录中的源码文件是作者为配合书中的教学...
C++ primer Plus的pdf资源
11-02
C++ primer Plus的pdf资源
C++ Primer Plus 第6版 中文版课后代码习题答案
03-10
《C++ Primer Plus 第6版 中文版》是一本深入浅出的C++学习书籍，其课后代码习题答案是学习过程中不可或缺的部分。这本书旨在帮助读者从零基础开始掌握C++编程语言，通过实例和习题来巩固理论知识，提升编程技能。...
C++ primer plus 课后习题答案
03-30
《C++ Primer Plus》是一本深受程序员喜爱的C++学习书籍，它深入浅出地介绍了C++编程语言的基础和高级特性。课后习题是学习过程中不可或缺的一部分，它们旨在帮助读者巩固理论知识，提高实际编程技能。这个压缩包...
CCF刷题计划——田地丈量
Caspiannn的博客
09-12 238
因为是左下，所以相对而言是要挑最小的，可以画图，简单看出，最大是x1,y1。同理，右上角也是，最大最大是（a,b），所以 rx<=a，ry<=b。不妨先按上述方法试试，试了之后就爽了，因为发现如果不存在，这两个点会在同一水平线上，所以rx=lx，计算出来的面积=0，我们可以不用分类，直接用上述方法。我想过用点作为分类的条件，那么情况只有三个，一个点在矩形内部，还有两个点在矩形内部，四个点都在。也不是，如果划的矩形超级大，那么重合的面积就是a*b，但是如果按照我之前的思路的话，就是没有交集。
【高创新】基于鲸鱼优化算法WOA-Transformer-LSTM实现故障识别Matlab实现.rar
09-18
1.版本：matlab2014/2019a/2024a 2.附赠案例数据可直接运行matlab程序。 3.代码特点：参数化编程、参数可方便更改、代码编程思路清晰、注释明细。 4.适用对象：计算机，电子信息工程、数学等专业的大学生课程设计、期末大作业和毕业设计。 替换数据可以直接使用，注释清楚，适合新手
《冯唐成事心法》学习笔记01：逆境来，了怎么办？
09-18
《冯唐成事心法》学习笔记01：逆境来，了怎么办？
c语言课程设计-职工资源管理系统.7z
09-18
c语言课程设计-职工资源管理系统.7z
VB个人邮件处理系统(源代码+系统).zip
最新发布
09-18
1、资源项目源码均已通过严格测试验证，保证能够正常运行； 2、项目问题、技术讨论，可以给博主私信或留言，博主看到后会第一时间与您进行沟通； 3、本项目比较适合计算机领域相关的毕业设计课题、课程作业等使用，尤其对于人工智能、计算机科学与技术等相关专业，更为适合； 4、下载使用后，可先查看REAdMe.md或论文文件（如有），本项目仅用作交流学习参考，请切勿用于商业用途。 5、资源来自互联网采集，如有侵权，私聊博主删除。 6、可私信博主看论文后选择购买源代码。 1、资源项目源码均已通过严格测试验证，保证能够正常运行； 2、项目问题、技术讨论，可以给博主私信或留言，博主看到后会第一时间与您进行沟通； 3、本项目比较适合计算机领域相关的毕业设计课题、课程作业等使用，尤其对于人工智能、计算机科学与技术等相关专业，更为适合； 4、下载使用后，可先查看REAdMe.md或论文文件（如有），本项目仅用作交流学习参考，请切勿用于商业用途。 5、资源来自互联网采集，如有侵权，私聊博主删除。 6、可私信博主看论文后选择购买源代码。 1、资源项目源码均已通过严格测试验证，保证能够正常运行； 2、项目问题、技术讨论，可以给博主私信或留言，博主看到后会第一时间与您进行沟通； 3、本项目比较适合计算机领域相关的毕业设计课题、课程作业等使用，尤其对于人工智能、计算机科学与技术等相关专业，更为适合； 4、下载使用后，可先查看READme.md或论文文件（如有），本项目仅用作交流学习参考，请切勿用于商业用途。 5、资源来自互联网采集，如有侵权，私聊博主删除。 6、可私信博主看论文后选择购买源代码。
C++primer Plus第2-13章编程练习答案详解
C++primer plus第2-13章答案解读 本资源摘要信息将对C++primer plus第2-13章的答案进行详细解读，涵盖了C++语言的基础知识和基本编程实践。 **第二章：开始学习C++** 本章节主要介绍了C++语言的基本概念和语法...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值