C++ Primer Plus习题及答案-第十章

最新推荐文章于 2023-05-22 19:32:58 发布
最新推荐文章于 2023-05-22 19:32:58 发布
阅读量677 收藏 6
点赞数 2
分类专栏： C++ Primer Plus习题及答案 文章标签： c++ 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jianmo1993/article/details/127195203
版权

习题选自：C++ Primer Plus(第六版)
内容仅供参考，如有错误，欢迎指正 !
文章首发微信公众号：iDoitnow

  • 构造函数是一种特殊的类成员函数，在创建类对象时被调用。
  • 构造函数的名称和类名相同，但通过函数重载，可创建多个同名的构造函数，条件是每个函数的特征标（参数列表）不同。
  • 每个成员函数（包括构造函数和析构函数）都有一个this指针，this指针指向调用对象，如果方法需要引用整个调用对象，则可以使用表达式*this。在函数的括号后面使用限定符将this限定为const，这样将不能使用this来修改对象的值。

复习题

1.什么是类？

类是用户定义的类型的定义。类声明指定了数据将如何存储，同时提供了访问和操作这些数据的方法。

2.类如何实现抽象、封装和数据隐藏？

用户可以根据类的公有接口对类对象执行的操作，这是抽象。类的数据成员可以是私有的（默认值），这意味着只能通过类成员函数来对数据进行访问，这是数据隐藏。实现的具体细节（如数据的表示和方法的代码）都是隐藏的，这是封装。

3.对象和类之间的关系是什么？

类定义了一种类型，包括如何使用它。对象是一个变量或其他的数据对象（如new生成的），并根据类定义被创建和使用。类和对象之间的关系同标准类型与其变量之间的关系。

4.除了是函数之外，类函数成员与类数据成员之间的区别是什么？

如果创建给定类的多个对象，则每个对象都有其自己的数据内存空间；但所有的对象都使用同一组成员函数（通常，这个方法是公有的，而数据是私有的，但这只是策略方面的问题，而不是对类的要求）

5.定义一个类来表示银行账户、数据成员包括储户姓名、帐号（使用字符串）和存款。成员函数执行如下操作：
  • 创建一个对象并将其初始化。
  • 显示储户姓名、帐号和存款。
  • 存入参数指定的存款。
  • 取出参数指定的款项。
请提供类声明，而不用给出方法实现。（编程练习1将要求编写实现）

#ifndef BANKACCOUNT_H
#define BANKACCOUNT_H
#include <string>

using namespace std;

class BankAccount
{
private:
    std::string name_str;
    std::string accountNum_str;
    double balance;

public:
    BankAccount(const string &name, const string &accountNum, double bal = 0.0);
    void show();
    void deposit(double cash);
    void withdraw(double cash);
};

#endif
6.类构造函数在何时被调用？类析构函数呢？

在创建类对象或显示调用构造函数时，类的构造函数被调用。当函数过期时，析构函数被调用。

7.给出复习题5中的银行账户的构造函数的代码。
#include "BankAccount.h"
#include <iostream>
using namespace std;

BankAccount::BankAccount(const string &name, const string &accountNum, double bal)
{
    name_str = name;
    accountNum_str = accountNum;
    balance = bal;
}

void BankAccount::show()
{
    cout << "Account Name : " << name_str << endl;
    cout << "Account Number : " << accountNum_str << endl;
    cout << "Account Balance : " << balance << endl;
}

void BankAccount::withdraw(double cash)
{
    balance -= cash;
}

void BankAccount::deposit(double cash)
{
    balance += cash;
}
8.什么是默认构造函数，拥有默认构造函数有何好处？

默认构造函数是没有参数或所有参数都有默认值的构造函数。拥有默认构造函数后，可以声明对象，而不初始化它，即使已经定义了初始化构造函数。它还使得能够声明数组。

9.修改Stock类的定义（stock20.h中的版本），使之包含返回各个数据成员值的成员函数。注意：返回公司名的成员函数不应该为修改数组提供便利，也就是说，不能简单的返回string引用。

原stock20.h的版本：

//Listing 10.7 stock20.h
// stock20.h -- augmented version
#ifndef STOCK20_H_
#define STOCK20_H_
#include <string>
class Stock
{
private:
    std::string company;
    int shares;
    double share_val;
    double total_val;
    void set_tot() { total_val = shares * share_val; }

public:
    Stock(); // default constructor
    Stock(const std::string &co, long n = 0, double pr = 0.0);
    ~Stock(); // do-nothing destructor
    void buy(long num, double price);
    void sell(long num, double price);
    void update(double price);
    void show() const;
    const Stock &topval(const Stock &s) const;
};
#endif

修改后：

#ifndef STOCK20_H_
#define STOCK20_H_
#include <string>
class Stock
{
private:
    std::string company;
    int shares;
    double share_val;
    double total_val;
    void set_tot() { total_val = shares * share_val; }

public:
    Stock();
    Stock(const std::string &co, long n = 0, double pr = 0.0);
    ~Stock();
    void buy(long num, double price);
    void sell(long num, double price);
    void update(double price);
    void show() const;
    const Stock &topval(const Stock &s) const;
    int shares() const { return shares; }
    double shareVal() const { return share_val; }
    double totalVal() const { return total_val; }
    const std::string &comp_name() const { return company; }
};
#endif
10.this和*this是什么？

this指针是类方法可以使用的指针，它指向用于调用方法的对象。因此，this是对象的地址，*this是对象本身。

编程练习

1.为复习题5描述的类提供方法定义，并编写一个小程序来演示所有的特性。

BankAccount.h:


#ifndef BANKACCOUNT_H
#define BANKACCOUNT_H
#include <string>

using namespace std;

class BankAccount
{
private:
    std::string name_str;
    std::string accountNum_str;
    double balance;

public:
    BankAccount(const string &name, const string &accountNum, double bal = 0.0);
    void show();
    void deposit(double cash);
    void withdraw(double cash);
};

#endif

BankAccount.cpp:

#include "BankAccount.h"
#include <iostream>
using namespace std;

BankAccount::BankAccount(const string &name, const string &accountNum, double bal)
{
    name_str = name;
    accountNum_str = accountNum;
    balance = bal;
}

void BankAccount::show()
{
    cout << "Account Name : " << name_str << endl;
    cout << "Account Number : " << accountNum_str << endl;
    cout << "Account Balance : " << balance << endl;
}

void BankAccount::withdraw(double cash)
{
    balance -= cash;
}

void BankAccount::deposit(double cash)
{
    balance += cash;
}

main.cpp:

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

using namespace std;

int main()
{
    string name, account;
    double num;
    cout << "enter name : ";
    getline(cin, name);
    cout << "enter bank account : ";
    getline(cin, account);

    BankAccount ba(name, account);
    cout << "enter the deposit amount : ";
    cin >> num;
    cin.get();
    ba.deposit(num);
    cout << "your current bank account information : ";
    ba.show();

    cout << "enter the withdrawal amount: ";
    cin >> num;
    cin.get();
    ba.withdraw(num);
    cout << "your current bank account information : ";
    ba.show();

    return 0;
}
2. 下面是一个非常简单的类定义：
class Person
{
private:
    static const int LIMIT = 25;
    string lname;      // Person’s last name
    char fname[LIMIT]; // Person’s first name
public:
    Person()
    {
        lname = "";
        fname[0] = '\0';
    }                                                    // #1
    Person(const string &ln, const char *fn = "Heyyou"); // #2
    // the following methods display lname and fname
    void Show() const;       // firstname lastname format
    void FormalShow() const; // lastname, firstname format
};
它使用了一个string对象和一个字符数组，让您能够比较它们的用法。请提供未定义的方法的代码，以完成这个类的实现。再编写一个使用这个类的程序，它使用了三种可能的构造函数的调用（没有参数、一个参数和两个参数）以及两种显示方法。下面是一个使用这些构造函数和方法的例子：
Person one;                      // use default constructor
Person two("Smythecraft");       // use #2 with one default argument
Person three("Dimwiddy", "Sam"); // use #2, no defaults one.Show();
cout << endl;
one.FormalShow();
// etc. for two and three

Person.h :

#ifndef PERSON_H
#define PERSON_H

#include <string>
using std::string;

class Person
{
private:
    static const int LIMIT = 25;
    string lname;      // Person’s last name
    char fname[LIMIT]; // Person’s first name
public:
    Person()
    {
        lname = "";
        fname[0] = '\0';
    }                                                    // #1
    Person(const string &ln, const char *fn = "Heyyou"); // #2
    // the following methods display lname and fname
    void Show() const;       // firstname lastname format
    void FormalShow() const; // lastname, firstname format
};

#endif

Person.cpp :

#include "Person.h"
#include <iostream>
using std::cout;
using std::endl;

Person::Person(const string &ln, const char *fn)
{
    lname = ln;
    strcpy(fname, fn);
}

void Person::FormalShow() const
{
    cout << fname << " " << lname << endl;
}

void Person::Show() const
{
    cout << fname << " , " << lname << endl;
}

main.cpp :

#include "Person.h"
#include <iostream>
using std::cout;
using std::endl;
int main()
{
    Person one;
    Person two("Smythecraft");
    Person three("Dimwiddy", "Sam");
    cout << "Person one : " << endl;
    one.Show();
    one.FormalShow();
    cout << "Person two : " << endl;
    two.Show();
    two.FormalShow();
    cout << "Person two : " << endl;
    three.Show();
    three.FormalShow();
    return 0;
}
3.完成第9章的编程练习1，但要用正确的golf类声明替换那里的代码。用带合适参数的构造函数替换setgolf(golf &, const char * , int)，以提供初始值。保留setgolf()的交互版本，但要用构造函数来实现它（例如，setgolf()的代码应该获得数据，将数据传递给构造函数来创建一个临时对象，并将其赋给调用对象，即*this）。

Golf.h：

#ifndef GOLF_H
#define GOLF_H

class Golf
{
public:
    Golf();
    Golf(const char *name, int hc);
    int setgolf();
    void sethandicap(int hc);
    void showgolf() const;

private:
    static const int Len = 40;
    char fullname[Len];
    int handicap;
};

#endif

Golf.cpp:

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

using namespace std;

Golf::Golf()
{
    strcpy(fullname, "DefaultName");
    handicap = 0;
}
Golf::Golf(const char *name, int hc)
{
    strcpy(fullname, name);
    handicap = hc;
}

int Golf::setgolf()
{
    cout << "please enter fullname : ";
    cin.getline(fullname, Len);
    if (strlen(fullname) == 0)
        return 0;
    else
    {
        cout << "please enter handicap : ";
        cin >> handicap;
        cin.get();
        return 1;
    }
}

void Golf::sethandicap(int hc)
{
    handicap = hc;
}

void Golf::showgolf() const
{
    cout << "fullname : " << fullname << ", handicap : " << handicap << endl;
}

main.cpp:

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

using namespace std;

int main()
{
    Golf ann("Ann Birdfree", 24), andy, arrGolf[3];
    ann.showgolf();

    andy.showgolf();
    andy.setgolf();
    andy.showgolf();
    andy.sethandicap(20);
    andy.showgolf();

    int i = 0;
    while (i < 3 && arrGolf[i].setgolf())
    {
        arrGolf[i].showgolf();
        i++;
        if (i < 3)
            cout << "next one: " << endl;
    }

    return 0;
}
4.完成第9章的编程练习4，但将Sales结构及相关的函数转换为一个类及其方法。用构造函数替换setSales(sales &, double [], int)函数。用构造函数实现setSales(Slaes &)方法的交互版本。将类保留在名称空间SALES 中。

sales.h:

//sales.h-----头文件
#ifndef SALES_H
#define SALES_H

namespace SALES
{
    const int QUARTERS = 4;
    class Sales
    {
    public:
        Sales();
        Sales(const double ar[], int n);
        void showSales();

    private:
        double sales[QUARTERS];
        double average;
        double max;
        double min;
    };
}

#endif

sales.cpp:

//sales.cpp-----源代码文件
#include "sales.h"
#include <iostream>

using namespace std;
namespace SALES
{
    Sales::Sales(const double ar[], int n)
    {
        double min = 0, max = 0, sum = 0;
        min = max = ar[0];
        for (int i = 0; i < n; i++)
        {
            sales[i] = ar[i];
            sum += ar[i];
            if (ar[i] > max)
            {
                max = ar[i];
            }
            if (ar[i] < min)
            {
                min = ar[i];
            }
        }
        average = sum / n;
    }

    Sales::Sales()
    {
        cout << "Please enter 4 quarters for sales:" << endl;
        cout << "the 1 quarter :";
        cin >> sales[0];
        min = max = sales[0];
        for (int i = 1; i < 4; i++)
        {
            cout << "the " << i << " quarter :";
            cin >> sales[i];
            if (max < sales[i])
            {
                max = sales[i];
            }
            if (min > sales[i])
            {
                min = sales[i];
            }
        }
        average = (sales[0] + sales[1] + sales[2] + sales[3]) / 4;
    }

    void Sales::showSales()
    {
        cout << "Display all information in sales : " << endl;
        cout << "The 4 quarters are $" << sales[0] << ", $" << sales[1] << ", $" << sales[2] << ", $" << sales[3] << endl;
        cout << "The average income is $" << average << endl;
        cout << "The maximum income is $" << max << endl;
        cout << "The minimum income is $" << min << endl;
    }
}

main.cpp:

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

using namespace SALES;
int main()
{
    double arr[4] = {3.4, 5.6, 2.5, 6.1};
    Sales s1(arr, 4);
    s1.showSales();
    Sales s2;
    s2.showSales();
    return 0;
}
5.考虑下面的结构声明：
struct customer {
char fullname[35];
double payment;
};
编写一个程序，它从栈中添加和删除customer结构（栈用Stack类声明表示）。每次customer结构被删除时，其payment的值都被加入到总数中，并报告总数。注意：应该可以直接使用Stack类而不作修改；只需修改typedef声明，使Item的类型为customer，而不是unsigned long即可.

stack.h :

#ifndef STACK_H
#define STACK_H

struct customer
{
    char fullname[35];
    double payment;
};

typedef customer Item;

class Stack
{
public:
    Stack();
    bool pop(Item &it);
    bool push(const Item &it);
    bool isfull() const;
    bool isempty() const;

private:
    double total;
    int top;
    enum
    {
        MAX = 10
    };
    Item item[MAX];
};

#endif

stack.cpp :

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

using namespace std;

Stack::Stack()
{
    top = 0;
    total = 0;
}

bool Stack::isempty() const
{
    return top == 0;
}

bool Stack::isfull() const
{
    return top == MAX;
}

bool Stack::pop(Item &it)
{
    if (top > 0)
    {
        it = item[--top];
        total += it.payment;
        cout << "An order has been processed, current total revenue : " << total << endl;
        return true;
    }
    else
    {
        return false;
    }
}

bool Stack::push(const Item &it)
{
    if (top < MAX)
    {
        item[top++] = it;
        return true;
    }
    else
    {
        return false;
    }
}

main.cpp :

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

using namespace std;

int main()
{
    Stack stack;
    customer cu;
    char ch;
    cout << "Press a to add a customer, P to process an order, and Q to exit." << endl;
    while (cin >> ch && toupper(ch) != 'Q')
    {
        while (cin.get() != '\n')
        {
            continue;
        }
        if (!isalpha(ch))
        {
            cout << '\a';
            continue;
        }
        switch (ch)
        {
        case 'a':
        case 'A':
            if (stack.isfull())
            {
                cout << "The order of 10 customers has been filled. Please process the existing order first !" << endl;
            }
            else
            {
                cout << "Add customer name : ";
                cin.getline(cu.fullname, 35);
                cout << "Add the customer's consumption amount : ";
                cin >> cu.payment;
                cout << "dsssd : " << stack.push(cu);
            }
            break;
        case 'p':
        case 'P':
            if (stack.isempty())
            {
                cout << " There are currently no unprocessed orders." << endl;
            }
            else
            {
                stack.pop(cu);
            }
            break;
        default:
            cout << " Input error！！！" << endl;
            break;
        }
        cout << "Press a to add a customer, P to process an order, and Q to exit." << endl;
    }
    return 0;
}
6.下面是一个类声明：
class Move
{
private:
    double x;
    double y;

public:
    Move(double a = 0, double b = 0); //sets x, y to a, b
    showmove() const;                 // shows current x, y values
    Move add(const Move &m) const;
    // this function adds x of m to x of invoking object to get new x,
    // adds y of m to y of invoking object to get new y, creates a new
    // move object initialized to new x, y values and returns it
    reset(double a = 0, double b = 0); // resets x,y to a, b
}
请提供成员函数的定义和测试这个类的程序。

move.h :

#ifndef MOVE_H
#define MOVE_H

class Move
{
private:
    double x;
    double y;

public:
    Move(double a = 0, double b = 0); //sets x, y to a, b
    void showmove() const;            // shows current x, y values
    Move add(const Move &m) const;
    // this function adds x of m to x of invoking object to get new x,
    // adds y of m to y of invoking object to get new y, creates a new
    // move object initialized to new x, y values and returns it
    void reset(double a = 0, double b = 0); // resets x,y to a, b
};

#endif

move.cpp :

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

Move::Move(double a, double b)
{
    x = a;
    y = b;
}

Move Move::add(const Move &m) const
{
    return Move(x + m.x, y + m.y);
}

void Move::showmove() const
{
    std::cout << "x is :" << x << std::endl;
    std::cout << "y is :" << y << std::endl;
}
void Move::reset(double a, double b)
{
    x = a;
    y = b;
}

main.cpp :

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

int main()
{
    Move m1(1, 2), m2(3, 4);
    m1.showmove();
    m2.showmove();
    m1.add(m2).showmove();
    m1.reset(5, 6);
    m1.showmove();
    return 0;
}
7.Betelgeusean plorg有这些特征.
数据：
  • plorg的名称不超过19个字符；
  • plorg有满意指数（CI），这是一个整数。
操作：
  • 新的plorg将有名称，其CI值为50；
  • plorg的CI可以修改；
  • plorg可以报告其名称和CI；
  • plorg的默认名称为“Plorga”。
请编写一个Plorg类声明（包括数据成员和成员函数原型）来表示plorg，并编写成员函数的函数定义。然后编写一个小程序，以演示Plorg类的所有特性。

plorg.h :

#ifndef PLORG_H
#define PLORG_H

class Plorg
{
private:
    char name[19];
    int CI;

public:
    Plorg();
    Plorg( const char *n, int ci);
    void show();
    void setCI(int ci);
};

#endif

plorg.cpp :

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

Plorg::Plorg()
{
    strcpy(name, "Plorg");
    CI = 0;
}
Plorg::Plorg(const char *n, int ci)
{
    strcpy(name, n);
    CI = ci;
}

void Plorg::setCI(int ci)
{
    CI = ci;
}

void Plorg::show()
{
    std::cout << "name : " << name << ", CI: " << CI << std::endl;
}

main.cpp :

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

int main()
{
    Plorg p1, p2("plorg2", 50);
    p1.show();
    p2.show();
    p1.setCI(30);
    p1.show();
}
8.可以将简单列表描述成下面这样：

  • 可存储0或多个类型的列表；

  • 可创建空列表

  • 可在列表中添加数据项；

  • 可确定列表是否为空；

  • 可确定列表是否已满；

  • 可访问列表中每一个数据项，并对它执行某种操作。

可以看到，这个列表确实很简单，例如它不允许插入或删除数据项。
请设计一个List类来表示这中数据类型。您应提供头文件list.h和实现文件list.cpp.前者包含定义，后者包含实现这个类的方法。您还应创建一个简短的程序来实现这个类。
该表的规范很简单，这主要旨在简化这个编程练习，可以选择使用数组或链表来实现这个列表，但公有结构不应依赖与说做的选择。也就是说，公有接口不应有数组索引，节点指针等。应使用通用概念来表达创建列表、在列表中添加数据项等操作。对于访问数据项以及执行操作，通常应使用将函数指针做为参数的函数来处理：

void visit(void (*pf) (Item&));

其中，pf指向一个将Item引用作为参数的函数（不是成员函数），Item是列表中数据项的类型，visit()函数将该函数用于列表中的每个数据项。

list.h :

#ifndef LIST_H
#define LIST_H

typedef int Item;
const int MAX = 10;
class List
{
private:
    Item ITEM[MAX];
    int COUNT;

public:
    List();
    bool isfull();
    bool isempty();
    bool addItem(Item it);
    Item *item();
    int count();
    void visit(void (*pf)(Item &));
};

#endif

list.cpp :

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

List::List()
{
    COUNT = 0;
}

bool List::isfull()
{
    return COUNT == MAX;
}

bool List::isempty()
{
    return COUNT == 0;
}
bool List::addItem(Item it)
{
    if (this->isfull())
    {
        std::cout << "full already, add fail. " << std::endl;
        return false;
    }
    else
    {
        ITEM[COUNT++] = it;
        return true;
    }
}

Item *List::item()
{
    return ITEM;
}

int List::count()
{
    return COUNT;
}

void List::visit(void (*pf)(Item &))
{
    for (int i = 0; i < COUNT; i++)
    {
        (*pf)(ITEM[i]);
    }
}

main.cpp :

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

void intadd2(int &n);

int main()
{
    List l;
    l.addItem(1);
    l.addItem(2);
    l.addItem(3);
    for (int i = 0; i < 3; i++)
    {
        std::cout << l.item()[i] << std::endl;
    }
    l.visit(intadd2);
    for (int i = 0; i < 3; i++)
    {
        std::cout << l.item()[i] << std::endl;
    }
    return 0;
}

void intadd2(int &n)
{
    n += 2;
}

原文链接

C++ Primer Plus习题及答案-第十章

艰默
关注
  • 2
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
C++Primer（第4版）-课后习题答案.pdf
11-01
C++Primer（第4版）_课后习题答案
C++ primer plus第十章编程练习答案
sakura0908的博客
09-06 191
编写一个程序，它从栈中添加和删除 customer 结构( 用 Sack 类声明表示)每次customer 结构被删除时，其 payment 的值都被加入到总数中，并报告总数。保setgolf )的交互版本但要用构造函数来实现它(例如，setgol)的代码应该获得数据，将数据传递给构造函数来创建一个临时对象，并将其赋给调用对象即*this)。请提供未定义的方法的代码,以完成这个类的实现。再编写一个使用这个类的程序，它使用了三种可能的构造函数调用(没有参数、一个参数和两个参数》以及两种显示方法。
Java-面向对象练习
m0_54241717的博客
08-13 453
java面向对象习题
C Primer Plus(6) 中文版 第10章 数组和指针 10.9 复合字面值 10.10 关键概念 10.11 本章小结
weixin_客子光阴的博客
08-20 113
C Primer Plus(6) 中文版 第10章 数组和指针 10.9 复合字面值
java之面试题
qsqxhx的博客
05-28 257
1.jdk ，jre，jvm三者关系关系？ JVM:英文全称，Java Virtual Machine,是Java虚拟机，用来运行Java程序 JRE:英文全称，Java Runtime Environment,是Java运行时环境，里边包含了Java运行时所需要的类库。 JDK:英文全称，Java Development Kit,是Java开发工具包，里边包含了Java的开发工具。例如java,javac等。 JRE=JVM+libs【Java运行时所需要的类库】 JDK=JRE+java开发工具 2.
javaStudy_day10
Yuippe的专栏
10-24 1509
第一次测试 一，选择和填空（共14题，每题2分，共28分） 1，下列代码 (D) class A{ class AInner{} } class B{ static class BInner{} } public class C{ private class CInner{} } 编译后生成几个.class文件？ A、3个 B、4个 C、5个 D、6个   2，
C++ primer plus 课后习题答案
03-30
这个文件是我买的资料。我看过，和C++ primer plus 这本书的课后习题非常吻合。
C++ primer plus课后编程练习题答案
04-22
C++ primer plus 答案，QT亲自运行成功，含有课后练习题，编程练习题。
C++ Primer Plus 第6版 中文版课后代码习题答案
03-10
包括第六版的中文思维导图 课后以及代码例程代码
C++Primer Plus附录源码等文件.zip
12-27
C++Primer Plus第六版的课后题练习题
C Primer Plus第十章 编程练习答案
10-30
C Primer Plus第十章 编程练习答案，亲测编译运动通过。
C Primer Plus第十章复习题参考答案
weixin_45291329的博客
03-18 1155
10.12复习题 13下面有两个函数原型： viod show(const double ar[],int n); viod show2(const double ar2[][3],int n); a,编写一个函数调用，把一个内含8，3，9，2的复合字面量传递给show（）函数。 b,编写一个函数调用，把一个2行3列的符合字面量（8，3，9作为第一行，5，4，1作为第二行）传递给show2（）函数。 10.3 编程练习 1修改程序10.7的rain.c程序，用指针进行计算（仍然要声明并初始化数
c++ Primer Plus 第十章 答案
weixin_45791686的博客
11-25 271
第1题 bankaccount.h //bankaccount.h #ifndef BANKACCOUNT_H_ #define BANKACCOUNT_H_ class Bankaccount { private: std::string m_name; std::string m_account; double m_money; public: Bankaccount(); Bankaccount(const std::string& name, const std::strin
C++程序设计c++.primer.plus第五版第十章编程练习部分答案
smile_allen的博客
03-30 484
C++程序设计 下面是一个类声明： class Move{ private: double x; double y; public: Move(double a=0,double b=0); // 给成员变量x赋值为a，y赋值为b。 showmove(); //显示当前x,y的值 reset(double a=0,double b=0);...
C++Primer第五版——习题答案+详解(完整版)
热门推荐
MISAYAONE的博客
12-21 32万+
C++Primer第五版——习题答案详解 看的也比较快，但是有很多东西确实用不上，所以很多都没有深入的探讨，但是知识点覆盖的很全面，每一道题涉及的知识点我都写上简单的解释了。 文中代码的中文注释也尽量都写上，自己皆编译通过。 水平有限，如有有误之处，希望大家不吝指教！ 下面的链接是 第一章：全部题目(第一章基础较多)http:/
C++primer plus 习题+答案
yj
05-22 2497
解释：一般来说，调用一个函数流程为：当前调用命令的地址被保存下来，程序将跳转到所调用的函数并执行该函数，最后跳转回之前所保存的命令地址。对于经常需要调用的小函数来说，这大大降低了程序运行效率。所以，新增了内联函数。关键字inline告诉编译器，任何地方只要调用内联函数，就直接把函数的机器码插入到调用它的地方。这样程序执行更有效率，就好像将内联函数中的语句直接插入到了源代码文件中需要调用该函数的地方一样。适合于：只有一行代码的小型，非递归函数适合作为内联函数。
C++ Primer Plus习题及答案（合集）
jianmo的博客
02-23 2485
C++ Primer Plus习题及答案（合集）
C Primer Plus(第6版)第十章复习题答案
weixin_42912350的博客
10-07 2623
10.12复习题 下面的程序将打印什么内容？ 应该会打印出ref数组元素的值，一行俩 #include &amp;amp;lt;stdio.h&amp;amp;gt; int main(void) { int ref[] = {8, 4, 0, 2}; int * ptr; int index; for (index = 0, ptr = ref; index &amp;amp;lt; 4; index++, ptr++) p...
C++primer plus第十章习题答案（部分）
心雨
05-15 439
第10章1 复习题2 编程题 1 复习题 1类是用户自定义类型的定义，类声明指出了数据如何存储，同时指定了访问数据的方法。 2类表示人们可以用类的共有接口对类对象执行操作，这是抽象。类的数据成员可以是私有的，这意味着只能通过成员函数来访问这些数据，这是数据隐藏。实现的具体细节（如数据表示和方法的代码）都是隐藏的，这是封装。 3类定义了一种类型，包括如何使用它。对象是一个变量或其他数据对象，并根据类定义创建和使用。类和对象之间的关系同标准类型煜其变量之间的关系相同。 4如果创建给定类的多个对象，则每个对象都
c++ primer plus 习题 pdf
最新发布
11-07
"C Primer Plus 习题 PDF" 是一个面向习题的电子书，主要用于帮助学习者巩固和加强对 C 语言编程的理解和实践。 该电子书提供了大量的习题和解答，通过完成这些习题，学习者可以锻炼和巩固自己的编程技能。书中的习题既有基础的语法和编程概念的练习，也有更加复杂的编程挑战，帮助学习者逐步提升自己的编程水平。 通过习题解答，学习者可以更好地理解和掌握书中所讲解的知识点。习题解答不仅仅是给出答案，更重要的是对问题进行解析和思考，从而帮助学习者理解问题的解决方法和原理。 该电子书以 PDF 格式发布，方便学习者在线或离线学习和阅读。学习者可以根据自己的进度和需要选择适合的习题进行练习，也可以根据自己的掌握情况选择相应的难度。 总之，"C Primer Plus 习题 PDF" 是一个有助于学习者巩固和提高 C 语言编程能力的资源，通过完成其中的习题，学习者可以更好地掌握并应用 C 语言编程知识。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

艰默

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值