C++ primer plus 课后练习题

已于 2023-04-16 21:30:46 修改
阅读量223 收藏
点赞数 1
文章标签： c++
于 2023-03-31 11:32:01 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Anesthi/article/details/129867185
版权

第十一章：使用类

        一、复习题

        1. 

Stonewt::Stonewt operator*(double n)
{
    Stonewt temp;
    temp.pounds = pounds * 14 * n;
    temp.stone = (int)temp.pounds / 14;
    temp.pounds_left = temp.pounds - temp.stone * 14;
    return temp;
}

        2. 友员函数并不是成员函数，因此不能使用对象通过.运算符来使用友员函数

        3. 不一定。如果类成员均为public，则不使用友员函数也能访问类成员。

        4. 

Stonewt::Stonewt operator*(double n, Stonewt & s)
{
    return s * n;
}

        5. . :: * ?: sizeof

        6. 只能在成员函数中重载他们

        7. 

Vector::operator double() const
{
    return mag;
}

        二、编程练习

        1.

#ifndef C_PRIMER_CHAPTER11_VECTOR_H
#define C_PRIMER_CHAPTER11_VECTOR_H

#include <iostream>
#include <fstream>

//namespace VECTOR {
    class Vector {
    public:
        enum Mode {
            RECT, POL
        };
    private:
        double x;
        double y;
        double mag;
        double ang;
        Mode mode;

        void set_mag();

        void set_ang();

        void set_x();

        void set_y();

    public:
        Vector();

        Vector(double n1, double n2, Mode form = RECT);

        void reset(double n1, double n2, Mode form = RECT);

        double x_val() { return x; }

        double y_val() { return y; }

        double mag_val() { return mag; }

        double ang_val() { return ang; }

        void polar_form();

        void rect_form();

        Vector operator+(const Vector &b) const;

        Vector operator-(const Vector &b) const;

        Vector operator-() const;

        Vector operator*(double n) const;

        friend Vector operator*(double n, const Vector &b);

        friend std::ostream &operator<<(std::ostream &os, const Vector &b);

        friend std::fstream &operator<<(std::fstream &ifs, const Vector &b);
    };
//}

#endif //C_PRIMER_CHAPTER11_VECTOR_H


#include "Vector.h"
#include <cmath>

using std::sqrt;
using std::sin;
using std::cos;
using std::atan;
using std::atan2;
using std::cout;

//using namespace VECTOR;

const double Rad_to_deg = 45.0 / atan(1.0);

void Vector::set_mag()
{
    mag = sqrt(x * x + y * y);
}

void Vector::set_ang()
{
    if(x == 0 && y == 0)
        ang = 0.0;
    else
        ang = atan2(y,x);
}

void Vector::set_x()
{
    x = mag * cos(ang);
}

void Vector::set_y()
{
    y = mag * sin(ang);
}

Vector::Vector()
{
    x = y = mag = ang = 0.0;
    mode = RECT;
}

Vector::Vector(double n1, double n2, Mode form)
{
    mode = form;
    if(mode == RECT)
    {
        x = n1;
        y = n2;
        set_mag();
        set_ang();
    }
    else
    {
        mag = n1;
        ang = n2 / Rad_to_deg;
        set_x();
        set_y();
    }
}

void Vector::reset(double n1, double n2, Mode form)
{
    mode = form;
    if(mode == RECT)
    {
        x = n1;
        y = n2;
        set_mag();
        set_ang();
    }
    else
    {
        mag = n1;
        ang = n2 / Rad_to_deg;
        set_x();
        set_y();
    }
}

void Vector::polar_form()
{
    mode = POL;
}

void Vector::rect_form()
{
    mode = RECT;
}

Vector Vector::operator+(const Vector &b) const
{
    return Vector(x + b.x, y + b.y);
}

Vector Vector::operator-(const Vector &b) const
{
    return Vector(x - b.x, y - b.y);
}

Vector Vector::operator-() const
{
    return Vector(-x,-y);
}

Vector Vector::operator*(double n) const
{
    return Vector(n*x,n*y);
}

Vector operator*(double n, const Vector &b)
{
    return b * n;
}

std::ostream & operator<<(std::ostream &os, const Vector & b)
{
    if(b.mode == Vector::RECT)
        os << "(x,y) = (" << b.x << ", " << b.y << ")";
    else
        os << "(m,a) = (" << b.mag << ", " << b.ang * Rad_to_deg << ")";
    return os;
}

std::fstream &operator<<(std::fstream &ifs, const Vector &b)
{
    if(b.mode == Vector::RECT)
        ifs << "(x,y) = (" << b.x << ", " << b.y << ")";
    else
        ifs << "(m,a) = (" << b.mag << ", " << b.ang * Rad_to_deg << ")";
    return ifs;
}
#include "Vector.h"
#include <iostream>
#include <cstdlib>
#include <ctime>
int main()
{
    using namespace std;

    srand(time(0));

    double direction;
    Vector step;
    Vector result(0.0,0.0);
    unsigned long steps = 0;
    double target;
    double dstep;

    cout << "Enter target distance (q to quit): ";
    while(cin >> target)
    {
        cout << "Enter step length: ";
        if(!(cin >> dstep))
            break;

        fstream ofs;
        ofs.open("record");
        ofs << "Target Distance: " << target << ", Step Size: " << dstep << endl;

        while(result.mag_val() < target)
        {
            ofs << "(x,y) = (" << result.x_val() << ", " << result.y_val() << ")" << endl;

            direction = rand() % 360;
            step.reset(dstep,direction,Vector::POL);
            result = result + step;

            steps++;
        }

        cout << "After " << steps << " steps, the subject "
                                     "has the following location: \n";
        cout << result << endl;
        result.polar_form();
        cout << " or\n" << result << endl;
        cout << "Average outward distance per step = "
        << result.mag_val()/steps << endl;

        steps = 0;
        result.reset(0.0,0.0);
        cout << "Enter target distance (q to quit): ";
    }

    return 0;
}

        2.

#ifndef C_PRIMER_CHAPTER11_VECTOR_H
#define C_PRIMER_CHAPTER11_VECTOR_H

#include <iostream>
#include <cmath>
#include <fstream>

namespace VECTOR {
    class Vector {
    public:
        enum Mode {
            RECT, POL
        };
    private:
        double x;
        double y;
        //double mag;
        //double ang;
        Mode mode;

        //void set_mag();

        //void set_ang();

        void set_x();

        void set_y();

    public:
        Vector();

        Vector(double n1, double n2, Mode form = RECT);

        void reset(double n1, double n2, Mode form = RECT);

        double x_val() { return x; }

        double y_val() { return y; }

        double mag_val() { return sqrt(x * x + y * y); }

        double ang_val() {
            if (x == 0 && y == 0)
                return 0.0;
            else
                return atan2(y, x);
        }

        void polar_form();

        void rect_form();

        Vector operator+(const Vector &b) const;

        Vector operator-(const Vector &b) const;

        Vector operator-() const;

        Vector operator*(double n) const;

        friend Vector operator*(double n, const Vector &b);

        friend std::ostream &operator<<(std::ostream &os, Vector b);

        friend std::fstream &operator<<(std::fstream &ifs, Vector b);
    };
}

#endif //C_PRIMER_CHAPTER11_VECTOR_H

#include "Vector.h"
#include <cmath>


using std::sqrt;
using std::sin;
using std::cos;
using std::atan;
using std::atan2;
using std::cout;

using namespace VECTOR;

const double Rad_to_deg = 45.0 / atan(1.0);
namespace VECTOR {
    /* void Vector::set_mag() {
        mag = sqrt(x * x + y * y);
    }

    void Vector::set_ang() {
        if (x == 0 && y == 0)
            ang = 0.0;
        else
            ang = atan2(y, x);
    }
    */
    void Vector::set_x() {
        x = mag_val() * cos(ang_val());
    }

    void Vector::set_y() {
        y = mag_val() * sin(ang_val());
    }

    Vector::Vector() {
        x = y = 0.0;
        mode = RECT;
    }

    Vector::Vector(double n1, double n2, Mode form) {
        mode = form;
        if (mode == RECT) {
            x = n1;
            y = n2;
        } else {
            x = n1 * cos(n2 / Rad_to_deg);
            y = n1 * sin(n2 / Rad_to_deg);
        }
    }

    void Vector::reset(double n1, double n2, Mode form) {
        mode = form;
        if (mode == RECT) {
            x = n1;
            y = n2;
        } else {
            x = n1 * cos(n2 / Rad_to_deg);
            y = n1 * sin(n2 / Rad_to_deg);
        }
    }

    void Vector::polar_form() {
        mode = POL;
    }

    void Vector::rect_form() {
        mode = RECT;
    }

    Vector Vector::operator+(const Vector &b) const {
        return Vector(x + b.x, y + b.y);
    }

    Vector Vector::operator-(const Vector &b) const {
        return Vector(x - b.x, y - b.y);
    }

    Vector Vector::operator-() const {
        return Vector(-x, -y);
    }

    Vector Vector::operator*(double n) const {
        return Vector(n * x, n * y);
    }

    Vector operator*(double n, const Vector &b) {
        return b * n;
    }

    std::ostream &operator<<(std::ostream &os, Vector b) {
        if (b.mode == Vector::RECT)
            os << "(x,y) = (" << b.x << ", " << b.y << ")";
        else
            os << "(m,a) = (" << b.mag_val() << ", " << b.ang_val() * Rad_to_deg << ")";
        return os;
    }

    std::fstream &operator<<(std::fstream &ifs, Vector b) {
        if (b.mode == Vector::RECT)
            ifs << "(x,y) = (" << b.x << ", " << b.y << ")";
        else
            ifs << "(m,a) = (" << b.mag_val() << ", " << b.ang_val() * Rad_to_deg << ")";
        return ifs;
    }
}

#include "Vector.h"
#include <iostream>
#include <cstdlib>
#include <ctime>
using namespace VECTOR;
int main() {
    using namespace std;

    srand(time(0));

    double direction;
    Vector step;
    Vector result(0.0, 0.0);
    unsigned long steps = 0;
    double target;
    double dstep;

    cout << "Enter target distance (q to quit): ";
    while (cin >> target) {
        cout << "Enter step length: ";
        if (!(cin >> dstep))
            break;

        fstream ofs;
        ofs.open("record");
        ofs << "Target Distance: " << target << ", Step Size: " << dstep << endl;

        while (result.mag_val() < target) {
            ofs << "(x,y) = (" << result.x_val() << ", " << result.y_val() << ")" << endl;

            direction = rand() % 360;
            step.reset(dstep, direction, Vector::POL);
            result = result + step;

            steps++;
        }

        cout << "After " << steps << " steps, the subject "
                                     "has the following location: \n";
        cout << result << endl;
        result.polar_form();
        cout << " or\n" << result << endl;
        cout << "Average outward distance per step = "
             << result.mag_val() / steps << endl;

        steps = 0;
        result.reset(0.0, 0.0);
        cout << "Enter target distance (q to quit): ";
    }

    return 0;
}

        3.

#include "Vector.h"
#include <iostream>
#include <cstdlib>
#include <ctime>
using namespace VECTOR;
int main() {
    using namespace std;

    srand(time(0));

    double direction;
    Vector step;
    Vector result(0.0, 0.0);
    unsigned long steps = 0;
    double target;
    double dstep;
    int tests;

    cout << "Enter target distance (q to quit): ";
    while (cin >> target) {
        cout << "Enter step length: ";
        if (!(cin >> dstep))
            break;

        cout << "Enter test time: ";
        if(!(cin >> tests))
            break;

        int* parr = new int[tests];
        int max = 0;
        int min = 999999999;
        int tot_steps = 0;

//        fstream ofs;
//        ofs.open("record");
//        ofs << "Target Distance: " << target << ", Step Size: " << dstep << endl;
        for(int i = 0;i <tests;i++) {
            while (result.mag_val() < target) {
//            ofs << "(x,y) = (" << result.x_val() << ", " << result.y_val() << ")" << endl;

                direction = rand() % 360;
                step.reset(dstep, direction, Vector::POL);
                result = result + step;

                steps++;
            }
/*
        cout << "After " << steps << " steps, the subject "
                                     "has the following location: \n";
        cout << result << endl;
        result.polar_form();
        cout << " or\n" << result << endl;
        cout << "Average outward distance per step = "
             << result.mag_val() / steps << endl;
*/
            parr[i] = steps;

            if(steps > max)
                max = steps;
            if(steps < min)
                min = steps;

            tot_steps += steps;

            steps = 0;
            result.reset(0.0, 0.0);
        }

        cout << "Max steps : " << max << endl;
        cout << "Min steps : " << min << endl;
        cout << "Avg steps : " << (double)tot_steps/tests << endl;

        delete [] parr;

        cout << "Enter target distance (q to quit): ";
    }

    return 0;
}

        4.

#ifndef C_PRIMER_CHAPTER11_TIME_H
#define C_PRIMER_CHAPTER11_TIME_H

#include <iostream>

class Time {
private:
    int hours;
    int minutes;
public:
    Time();

    explicit Time(int, int = 0);

    void AddMin(int);

    void AddHr(int);

    void Reset(int = 0, int = 0);

    friend Time operator+(const Time &a, const Time &b);

    friend Time operator-(const Time &a, const Time &b);

    friend Time operator*(const Time &a, double b);

    friend Time operator*(double b, const Time &a);

    friend std::ostream &operator<<(std::ostream &os, const Time &a);
};


#endif //C_PRIMER_CHAPTER11_TIME_H

#include "Time.h"

Time::Time() {
    hours = minutes = 0;
}

Time::Time(int hr, int mins) {
    hours = hr;
    minutes = mins;
}

void Time::AddMin(int mins) {
    minutes += mins;
    hours += minutes / 60;
    minutes %= 60;
}

void Time::AddHr(int hr) {
    hours += hr;
}

void Time::Reset(int hr, int mins) {
    hours = hr;
    minutes = mins;
}

Time operator+(const Time &a, const Time &b) {
    int min = a.minutes + b.minutes;
    int hr = a.hours + b.hours + min / 60;
    min %= 60;
    return Time(hr, min);
}

Time operator-(const Time &a, const Time &b) {
    int min = a.minutes - b.minutes;
    int hr = a.hours - b.hours;
    return Time(hr, min);
}

Time operator*(const Time &a, double b) {
    long totmins = a.hours*60*b + a.minutes*b;
    int min = totmins % 60;
    int hr = totmins / 60;
    return Time(hr, min);
}

Time operator*(double b, const Time &a) {
    return a * b;
}

std::ostream &operator<<(std::ostream &os, const Time &a) {
    os << a.hours << " hours, " << a.minutes << " minutes";
    return os;
}
#include "Time.h"
#include <iostream>

int main()
{
    using std::cout;
    using std::endl;

    Time aida(3,35);
    Time tosca(2,48);
    Time temp;

    cout << "Aida and Tosca: \n";
    cout << aida << "; " << tosca << endl;
    temp = aida + tosca;
    cout << "Aida + Tosca: " << temp << endl;
    temp = aida * 1.17;
    cout << "Aida * 1.17: " << temp << endl;
    cout << "10.0 * Tosca: " << 10.0 * tosca << endl;

    return 0;
}

        5.

#ifndef C_PRIMER_CHAPTER11_STONEWT_H
#define C_PRIMER_CHAPTER11_STONEWT_H

#include <iostream>

class Stonewt {
public:
    enum Mode {
        STONE, POUNDS
    };
private:
    enum {
        Lbs_per_stn = 14
    };
    int stone;
    double pds_left;
    double pounds;
    Mode mode;
public:
    Stonewt(double lbs);

    Stonewt(int stn, double lbs);

    Stonewt();

    void set_Pounds();

    void set_Stone();

    Stonewt operator+(const Stonewt &b) const;

    Stonewt operator-(const Stonewt &b) const;

    Stonewt operator*(double n) const;

    friend Stonewt operator*(double n, const Stonewt &b);

    friend std::ostream &operator<<(std::ostream &os, const Stonewt &s);
};

#endif //C_PRIMER_CHAPTER11_STONEWT_H

#include "Stonewt.h"

Stonewt::Stonewt(double lbs) {
    stone = (int) lbs / Lbs_per_stn;
    pds_left = lbs - stone * Lbs_per_stn;
    pounds = lbs;
    mode = POUNDS;
}

Stonewt::Stonewt(int stn, double lbs) {
    stone = stn;
    pds_left = lbs;
    pounds = stn * Lbs_per_stn + lbs;
    mode = STONE;
}

Stonewt::Stonewt() {
    stone = pds_left = pounds = 0;
    mode = POUNDS;
}

void Stonewt::set_Pounds() {
    mode = POUNDS;
}

void Stonewt::set_Stone() {
    mode = STONE;
}

Stonewt Stonewt::operator+(const Stonewt &b) const {
    return Stonewt(pounds + b.pounds);
}

Stonewt Stonewt::operator-(const Stonewt &b) const {
    return Stonewt(pounds - b.pounds);
}

Stonewt Stonewt::operator*(double n) const {
    return Stonewt(pounds * n);
}

Stonewt operator*(double n, const Stonewt &b) {
    return b * n;
}

std::ostream &operator<<(std::ostream &os, const Stonewt &s) {
    if (s.mode == Stonewt::POUNDS) {
        os << s.pounds << " pounds";
    } else {
        os << s.stone << " stones, " << s.pds_left << " pounds";
    }
    return os;
}
#include "Stonewt.h"
#include <iostream>

int main() {
    using std::cout;
    using std::endl;

    Stonewt s1(9, 2.8);
    Stonewt s2(231.7);

    cout << "s1: " << s1 << ", s2: " << s2 << endl;
    cout << "s1 + s2: " << s1 + s2 << endl;
    cout << "s2 - s1: " << s2 - s1 << endl;
    cout << "1.5 * s1: " << 1.5 * s1 << endl;
    cout << "s2 * 2.5: " << s2 * 2.5 << endl;

    s2.set_Stone();
    cout << "another version of s2: " << s2 << endl;
    s1.set_Pounds();
    cout << "another version of s1: " << s1 << endl;

    return 0;
}

        6.

#ifndef C_PRIMER_CHAPTER11_STONEWT_H
#define C_PRIMER_CHAPTER11_STONEWT_H

#include <iostream>

class Stonewt {
public:
    enum Mode {
        STONE, POUNDS
    };
private:
    enum {
        Lbs_per_stn = 14
    };
    int stone;
    double pds_left;
    double pounds;
    Mode mode;
public:
    Stonewt(double lbs);

    Stonewt(int stn, double lbs);

    Stonewt();

    void set_Pounds();

    void set_Stone();

    Stonewt operator+(const Stonewt &b) const;

    Stonewt operator-(const Stonewt &b) const;

    Stonewt operator*(double n) const;

    bool operator<(const Stonewt &b) const;

    bool operator>(const Stonewt &b) const;

    bool operator<=(const Stonewt &b) const;

    bool operator>=(const Stonewt &b) const;

    bool operator==(const Stonewt &b) const;

    bool operator!=(const Stonewt &b) const;

    friend Stonewt operator*(double n, const Stonewt &b);

    friend std::ostream &operator<<(std::ostream &os, const Stonewt &s);
};

#endif //C_PRIMER_CHAPTER11_STONEWT_H

#include "Stonewt.h"

Stonewt::Stonewt(double lbs) {
    stone = (int) lbs / Lbs_per_stn;
    pds_left = lbs - stone * Lbs_per_stn;
    pounds = lbs;
    mode = POUNDS;
}

Stonewt::Stonewt(int stn, double lbs) {
    stone = stn;
    pds_left = lbs;
    pounds = stn * Lbs_per_stn + lbs;
    mode = STONE;
}

Stonewt::Stonewt() {
    stone = pds_left = pounds = 0;
    mode = POUNDS;
}

void Stonewt::set_Pounds() {
    mode = POUNDS;
}

void Stonewt::set_Stone() {
    mode = STONE;
}

Stonewt Stonewt::operator+(const Stonewt &b) const {
    return Stonewt(pounds + b.pounds);
}

Stonewt Stonewt::operator-(const Stonewt &b) const {
    return Stonewt(pounds - b.pounds);
}

Stonewt Stonewt::operator*(double n) const {
    return Stonewt(pounds * n);
}

bool Stonewt::operator<(const Stonewt &b) const {
    return pounds < b.pounds;
}

bool Stonewt::operator>(const Stonewt &b) const {
    return pounds > b.pounds;
}

bool Stonewt::operator<=(const Stonewt &b) const {
    return pounds <= b.pounds;
}

bool Stonewt::operator>=(const Stonewt &b) const {
    return pounds >= b.pounds;
}

bool Stonewt::operator==(const Stonewt &b) const {
    return pounds == b.pounds;
}

bool Stonewt::operator!=(const Stonewt &b) const {
    return pounds != b.pounds;
}

Stonewt operator*(double n, const Stonewt &b) {
    return b * n;
}

std::ostream &operator<<(std::ostream &os, const Stonewt &s) {
    if (s.mode == Stonewt::POUNDS) {
        os << s.pounds << " pounds";
    } else {
        os << s.stone << " stones, " << s.pds_left << " pounds";
    }
    return os;
}
#include "Stonewt.h"
#include <iostream>

int main() {
    using std::cout;
    using std::endl;
    using std::cin;
/*
    Stonewt s1(9, 2.8);
    Stonewt s2(231.7);

    cout << "s1: " << s1 << ", s2: " << s2 << endl;
    cout << "s1 + s2: " << s1 + s2 << endl;
    cout << "s2 - s1: " << s2 - s1 << endl;
    cout << "1.5 * s1: " << 1.5 * s1 << endl;
    cout << "s2 * 2.5: " << s2 * 2.5 << endl;

    s2.set_Stone();
    cout << "another version of s2: " << s2 << endl;
    s1.set_Pounds();
    cout << "another version of s1: " << s1 << endl;
*/
    Stonewt arr[6] = {{120.5},
                      {250.8},
                      {821.6}};
    for (int i = 0; i < 3; i++) {
        cout << "Enter the pounds you want: ";
        double temp;
        cin >> temp;
        arr[i + 3] = Stonewt(temp);
    }

    Stonewt cmp(11, 0.0);
    Stonewt max = arr[0];
    Stonewt min = arr[0];
    int count = 0;
    for (int i = 0; i < 6; i++) {
        if (max < arr[i]) {
            max = arr[i];
        }
        if (min > arr[i]) {
            min = arr[i];
        }
        if (arr[i] >= cmp) {
            count++;
        }
    }

    cout << "The biggest: " << max << endl;
    cout << "The smallest: " << min << endl;
    cout << "Count: " << count << endl;

    return 0;
}

        7.

#ifndef C_PRIMER_CHAPTER11_PLURAL_H
#define C_PRIMER_CHAPTER11_PLURAL_H

#include <iostream>

class Plural {
private:
    double x;
    double y;
public:
    Plural();

    Plural(double x, double y);

    Plural operator+(const Plural &b) const;

    Plural operator-(const Plural &b) const;

    Plural operator*(const Plural &b) const;

    Plural operator~() const;

    friend Plural operator*(double n, const Plural &b);

    friend std::ostream &operator<<(std::ostream &os, const Plural &b);

    friend std::istream &operator>>(std::istream &is, Plural &b);
};


#endif //C_PRIMER_CHAPTER11_PLURAL_H

#include "Plural.h"

Plural::Plural() {
    x = y = 0.0;
}

Plural::Plural(double x, double y) {
    this->x = x;
    this->y = y;
}

Plural Plural::operator+(const Plural &b) const {
    return Plural(x + b.x, y + b.y);
}

Plural Plural::operator-(const Plural &b) const {
    return Plural(x - b.x, y - b.y);
}

Plural Plural::operator*(const Plural &b) const {
    return Plural(x * b.x - y * b.y, x * b.y + y * b.x);
}

Plural Plural::operator~() const {
    return Plural(x, -y);
}

Plural operator*(double n, const Plural &b) {
    return Plural(n * b.x, n * b.y);
}

std::ostream &operator<<(std::ostream &os, const Plural &b) {
    os << "(" << b.x << "," << b.y << "i)";
    return os;
}

std::istream &operator>>(std::istream &is, Plural &b) {
    std::cout << "real: ";
    if (is >> b.x) {
        std::cout << "imaginary part: ";
        is >> b.y;
    }
    return is;
}
#include "Plural.h"
#include <iostream>

using namespace std;

int main() {
    Plural a(3.0, 4.0);
    Plural c;

    cout << "Enter a complex number (q to quit): \n";
    while (cin >> c) {
        cout << "c is " << c << '\n';
        cout << "complex conjugate is " << ~c << '\n';
        cout << "a is " << a << '\n';
        cout << "a + c is " << a + c << '\n';
        cout << "a - c is " << a - c << '\n';
        cout << "a * c is " << a * c << '\n';
        cout << "2 * c is " << 2 * c << '\n';
        cout << "Enter a complex number (q to quit): \n";
    }
    cout << "Done!\n";
    return 0;
}

Anesthi
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
C++ primer plus 课后习题个人练习
weixin_43748679的博客
09-12 692
C++ primer plus exercises
C++ primer plus 课后习题答案
03-30
C++ Primer Plus的课后习题涵盖了许多关键知识点，包括但不限于： 1. **基本语法**：变量声明、数据类型、运算符、流程控制（如if、switch、for、while）、函数的使用等。 2. **指针与引用**：理解内存地址、指针...
C++ primer plus课后练习题
Anesthi的博客
04-16 150
为使类A拥有一个本身为类B的成员函数的友元，B的声明必须位于 A 的声明之前。同样，如果B拥有一个本身是A 的成员函数的友元，则A 的这个声明必须位于B的声明之前。6. 第一个实例中，可以调用superb中的say方法以及superb派生类magnificent中的say方法。7. static_cast运算符能在类层次中进行向上或向下的转换，但dynamic_cast运算符仅能进行向上的转换。4. return会依次回调先前调用该函数的函数，但throw会跳转到相应的含有try块的调用函数中进行处理。
C++primer plus 习题+答案
yj
05-22 2632
解释：一般来说，调用一个函数流程为：当前调用命令的地址被保存下来，程序将跳转到所调用的函数并执行该函数，最后跳转回之前所保存的命令地址。对于经常需要调用的小函数来说，这大大降低了程序运行效率。所以，新增了内联函数。关键字inline告诉编译器，任何地方只要调用内联函数，就直接把函数的机器码插入到调用它的地方。这样程序执行更有效率，就好像将内联函数中的语句直接插入到了源代码文件中需要调用该函数的地方一样。适合于：只有一行代码的小型，非递归函数适合作为内联函数。
C++ Primer Plus习题及答案（合集）
jianmo的博客
02-23 3178
C++ Primer Plus习题及答案（合集）
C++ Primer Plus课后练习题 代码
03-27
通过实践这些课后练习题，你可以逐步加深对C++的理解，提高编程能力，为解决更复杂的问题打下坚实基础。在学习过程中，不断交流和讨论是至关重要的，因为它能帮助你发现自己的不足，从他人的经验中受益，从而共同...
C++ primer plus课后编程练习题答案
04-22
C++ Primer Plus 课后编程练习题答案 C++ Primer Plus 是一本经典的 C++ 程序设计教材，旨在帮助读者学习 C++ 语言的基础知识和高级编程技术。本书涵盖了 C++ 语言的所有方面，包括基本语法、数据类型、函数、数组...
c++ primer plus课后习题
08-21
这些只是《C++ Primer Plus》中部分核心概念，通过书中的习题，你可以深入理解和掌握这些知识点，并逐步提升你的C++编程技能。如果你在做习题过程中遇到困难，可以查阅书籍、在线资源或寻求他人帮助，不断实践和反思...
C++ Primer Plus 第6版 中文版课后代码习题答案
03-10
《C++ Primer Plus 第6版 中文版》是一本深入浅出的C++学习书籍，其课后代码习题答案是学习过程中不可或缺的部分。这本书旨在帮助读者从零基础开始掌握C++编程语言，通过实例和习题来巩固理论知识，提升编程技能。...
2024年C++面试题汇总及答案解析
soaring_casia的专栏
07-25 590
唯一的指针，不允许其他指针与他共享指向的对象。比如指针指向的内存被释放了，但是指针没有置nullptr. 多个指针指向同一个内存，当free掉一个指针之后，其他指针就变成了野指针。C++这些年虽然难度大，但是热度仍然不减，在编程排行榜基本上都是前几位，得益于它良好的薪资待遇。SPI协议是一种采用主从模式的串行，全双工，同步通信总线，包括时钟，输入，输出，片选四个信号线，片选信号用于选择slave设备，输入输出的每个bit都需要和时钟沿同步。区别：指针指向一块儿内存，他的内容是所指内存的地址。
C++：文件操作基础
2301_79959126的博客
07-27 127
本文介绍了如何用C++实现基本的文件操作，主要讲解了fstream库的几个基础函数。
【C++】C++中的find方法介绍
qq_35902025的博客
07-25 400
find 函数是 std::string 类中非常有用的成员函数之一，它提供了灵活的方式来查找子字符串或字符。使用 npos 可以检查查找操作是否成功。
背单词工具(C++)
zeyeqianli的博客
07-24 3391
【代码】背单词工具(C++)
Python(C++)大尺度分层边值时变图统计推理并行算法
最新发布
跨学科知识视角展现
07-29 1036
:dart:分层结构制定生成模型 | :dart:贝叶斯模型选择程序 | :dart:分层结构图的信息性 | :dart:分层模型适应实值边协变量的网络 | :dart:分层模型适应时变网络，划分层对应于检测变化点 | :dart:定义两种版本随机块模型：:pen:具有边缘协变量模型概率分布，分层图总似然 | :pen:独立分层模型分层图数学似然计算 | :dart:推理算法：大图形尺度并行计算算法，过滤暂时被遮蔽的节点和边
C 语言动态链表
qq_68495605的博客
07-25 1082
动态链表是通过结点（Node）的集合来非连续地存储数据，结点之间通过指针相互连接。动态链表本身就是一种动态分配内存的数据结构。每个结点都包含数据部分和指向下一个节点的指针。这种结构允许在运行时动态地添加、删除或修改结点，而不需要像数组那样担心容量问题。
C：图案打印
2401_85010100的博客
07-23 950
空心正方形，空心三角形，X形，沙漏图案打印
C++ //练习 15.28 定义一个存放Quote对象的vector，将Bulk_quote对象传入其中。计算vector中所有元素总的net_price。
Made in Code
07-25 618
C++ Primer（第5版） 练习 15.28
C语言系统调用linux文件系统
C or CPP
07-25 802
在C语言中，openwrite和read函数是系统调用（system calls），它们直接由操作系统提供，用于底层的文件操作。这些函数是UNIX和类UNIX系统（如Linux）中的标准接口，不同于C标准库中的文件操作函数（如fopenfwrite和fread。
C++ Primer Plus课后习题解大全
"c++primerplus 课后习题答案" C++ Primer Plus是一本广泛使用的C++编程语言教程，适合初学者和有一定经验的程序员深入学习C++。该书覆盖了C++的基础到高级主题，包括面向对象编程、模板和STL（标准模板库）。提供...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值