Решение всех задач из учебника Стивена Праты

#include <iostream>
#include <string>
 
int main()
{
    std::string str;
 
    int count = 0;
 
    std::cout << "Enter words (to stop, type the word done):\n";
    std::cin >> str;
 
    while (str != "done")
    {
        ++count;
        std::cin >> str;
    }
 
    std::cout
    << "\nYou entered a total of "
    << count
    << " words.";
 
    return 0;
}

#include <iostream>
#include "golf.h"
 
int ArSize = 5;
 
int main()
{
    golf players[5];
 
    setgolf(players[0], "Ann Birdfree", 24);
 
    int count = 1;
    while(count < ArSize && setgolf(players[count]) == 1) // присваиваем структуре имя игрока и его гандикап, одновременно проверяя кол-во игроков
        count++; // счетчик игроков ( <=5 )
 
    for(int i = 0; i < count; i++)
        showgolf(players[i]);       //выводим на экран имена игроков и их гандикап
 
    for(int i = 0; i < count; i++)
        handicap(players[i], i);    //вносим изменения
 
    std::cout << "\nAfter edit handicap: ";
 
    for(int i = 0; i < count; i++)
        showgolf(players[i]);       //снова выводим на экран имена игроков и их гандикап
 
    return 0;
}

#include <iostream>
#include "golf.h"
#include <cstring> // для strcpy()
 
void setgolf(golf &g, const char *name, int hc)
{
    strcpy(g.fullname, name);
    g.handicap = hc;
}
 
int setgolf(golf &g)
{
    using namespace std;
 
    char ch;
    int count = 0;
 
    cout << "Enter name (empty string for quit): ";
    while(cin.get(ch) && ch != '\n' && count < Len) // вводим строку, одновременно проверяя не нажата ли клавиша "Enter" и не закончился ли массив
    {
        g.fullname[count] = ch;     // копируем введенную строку в массив
        count++;                    // обновляем счетчик введенных символов
    }
 
    if(count != 0)
    {
        g.fullname[count++] = '\0'; // добавляем символ окончания строки для верного ее вывода на экран
        cout << "Enter handicap: ";
        cin >> g.handicap;
        cin.sync();                 // избавляемся от символа переноса строки
        return 1;
    }
    else return 0;
}
void handicap(golf &g, int hc)
{
    g.handicap = hc;
}
void showgolf(const golf &g)
{
    using namespace std;;
    cout << "\nFullname: " << g.fullname;
    cout << "\nHandicap: " << g.handicap << endl;
}

#include <iostream>
#include <string>
 
using std::cout;
using std::cin;
using std::string;
 
void strcount(const string);
 
int main()
{
    string input;
 
    getline(cin, input);
    while(input != "")
    {
        strcount(input);
        cout << "Enter a line: \n";
        getline(cin, input);
    }
    cout << "Bye!\n";
 
    return 0;
}
 
void strcount(const string str)
{
    int count = 0;
    static int total = 0;
 
    cout << str << " contains ";
 
    for(int i = 0; i < str.size(); i++)
    {
        if(str[i] != ' ')
            count++;
    }
    total += count;
    cout << count << " characters\n";
    cout << total << " characters\n";
}

#include <iostream>
#include <cstring>
#include <new>
 
const int ArSize = 20;
const int BufSize = 100;
 
struct chaff
{
    char dross[ArSize];
    int slag;
};
void setchaff(chaff &obj, const char *dross, int slag);
void showchaff(chaff &obj);
 
char buffer[BufSize];
 
int main()
{
    ////////////////////BUFFER/////////////////////////
    chaff *mass = new (buffer) chaff [2];
    setchaff(mass[0], "Hello world!", 100);
    setchaff(mass[1], "Goodnight friend!", 200);
 
    showchaff(mass[0]);
    showchaff(mass[1]);
 
    ////////////////WITHOUT BUFFER//////////////////////
    chaff *arr = new chaff [2];
    setchaff(arr[0], "Hello world!", 100);
    setchaff(arr[1], "Goodnight friend!", 200);
 
    showchaff(arr[0]);
    showchaff(arr[1]);
 
    delete [] arr;
    return 0;
}
 
void setchaff(chaff &obj, const char *dross, int slag)
{
    strcpy(obj.dross, dross); // копируем строку в массив
    obj.slag = slag;
}
void showchaff(chaff &obj)
{
    std::cout << "dross: " << obj.dross;             //отображаем оба
    std::cout << "\nslag: " << obj.slag << std::endl;  //значения
}

// header.h
namespace SALES
{
    const int QUARTERS = 4;
    struct Sales
    {
        double sales[QUARTERS];
        double average;
        double max;
        double min;
    };
 
    void setSales(Sales &s, const double ar[], int n = QUARTERS); // параметр по умолчанию "n"
    void setSales(Sales &s);
    void showSales(const Sales &s);
}

// sales.cpp
#include <iostream>
#include "header.h"
 
namespace SALES
{
    void setSales(Sales &s, const double ar[], int n)
    {
        double sum = 0;
        s.min = ar[0];
        s.max = ar[0];
 
        int i;
        for(i = 0; i < n; i++)  // присваиваем
        {
            s.sales[i] = ar[i]; // массиву структуры значения
            if(ar[i] > s.max)
                s.max = ar[i];  // максимальное значение
            if(ar[i] < s.min)
                s.min = ar[i];  // минимальное значение
            sum += ar[i];       // находим сумму всех значений
        }
        s.average = sum/i;      // находим и присваиваем срежнее значение
 
        for( ; i < QUARTERS; i++)
            s.sales[i] = 0;      // заполняем оставшиеся элементы нулями
    }
 
    void setSales(Sales &s)
    {
        for(int i = 0; i < QUARTERS; i++)
        {
            std::cout <<  (i+1) << ". Enter the number of sales for the quarter: ";
            std::cin >> s.sales[i];
        }
        std::cout << std::endl;
 
        s.min = s.sales[0];
        s.max = s.sales[0];
 
        double sum = 0;
        int i;
        for(i = 0; i < QUARTERS; i++)
        {
            if(s.sales[i] > s.max)
                s.max = s.sales[i];
            if(s.sales[i] < s.min)
                s.min = s.sales[i];
            sum += s.sales[i];
        }
        s.average = sum/i;
    }
    void showSales(const Sales &s)
    {
        std::cout << "Sales for each quarter: ";
        for(int i = 0; i < QUARTERS; i++)
            std::cout << s.sales[i] << ' ';
        std::cout << std::endl;
        std::cout << "Min sales: " << s.min << std::endl;
        std::cout << "Max sales: " << s.max << std::endl;
        std::cout << "Average sales: " << s.average << std::endl;
        std::cout << std::endl;
    }
}

// main.cpp
#include "header.h"
 
int main()
{
 
 
    SALES::Sales one, two;
    double ArSales[3] = {10, 20, 30};
 
    SALES::setSales(one, ArSales, 3);
    SALES::setSales(two);
 
    SALES::showSales(one);
    SALES::showSales(two);
 
    return 0;
}

// string1.h -- fixed and augmented string class definition
 
#define _CRT_SECURE_NO_WARNINGS
#ifndef STRING1_H_
#define STRING1_H_
#include <iostream>
using std::ostream;
using std::istream;
 
class String
{
private:
    char * str;             // pointer to string
    int len;                // length of string
    static int num_strings; // number of objects
    static const int CINLIM = 80;  // cin input limit
public:
// constructors and other methods
    String(const char * s); // constructor
    String();               // default constructor
    String(const String &); // copy constructor
    ~String();              // destructor
    int length () const { return len; }
// overloaded operator methods    
    String & operator=(const String &);
    String & operator=(const char *);
    char & operator[](int i);
    const char & operator[](int i) const;
// overloaded operator friends
    friend bool operator<(const String &st, const String &st2);
    friend bool operator>(const String &st1, const String &st2);
    friend bool operator==(const String &st, const String &st2);    
    friend ostream & operator<<(ostream & os, const String & st);
    friend String operator+(const char *a, const String & b);
    friend String operator+(const String &a, const String & b);
    friend istream & operator>>(istream & is, String & st);
    void stringup();
    void stringlow();
    int has(char a);
// static function
    static int HowMany();
};
#endif

// string1.cpp -- String class methods
#define _CRT_SECURE_NO_WARNINGS
#include <cstring>                 // string.h for some
#include "string1.h"       
#include <cctype>
using std::cin;
using std::cout;
 
// initializing static class member
 
int String::num_strings = 0;
 
// static method
int String::HowMany()
{
    return num_strings;
}
 
// class methods
String::String(const char * s)     // construct String from C string
{
    len = std::strlen(s);          // set size
    str = new char[len + 1];       // allot storage
    std::strcpy(str, s);           // initialize pointer
    num_strings++;                 // set object count
}
 
String::String()                   // default constructor
{
    len = 4;
    str = new char[1];
    str[0] = '\0';                 // default string
    num_strings++;
}
 
String::String(const String & st)
{
    num_strings++;             // handle static member update
    len = st.len;              // same length
    str = new char [len + 1];  // allot space
    std::strcpy(str, st.str);  // copy string to new location
}
 
String::~String()                     // necessary destructor
{
    --num_strings;                    // required
    delete [] str;                    // required
}
 
// overloaded operator methods    
 
    // assign a String to a String
String & String::operator=(const String & st)
{
    if (this == &st)
        return *this;
    delete [] str;
    len = st.len;
    str = new char[len + 1];
    std::strcpy(str, st.str);
    return *this;
}
 
    // assign a C string to a String
String & String::operator=(const char * s)
{
    delete [] str;
    len = std::strlen(s);
    str = new char[len + 1];
    std::strcpy(str, s);
    return *this;
}
 
    // read-write char access for non-const String
char & String::operator[](int i)
{
    return str[i];
}
 
    // read-only char access for const String
const char & String::operator[](int i) const
{
    return str[i];
}
 
// overloaded operator friends
 
bool operator<(const String &st1, const String &st2)
{
    return (std::strcmp(st1.str, st2.str) < 0);
}
 
bool operator>(const String &st1, const String &st2)
{
    return st2 < st1;
}
 
bool operator==(const String &st1, const String &st2)
{
    return (std::strcmp(st1.str, st2.str) == 0);
}
 
    // simple String output
ostream & operator<<(ostream & os, const String & st)
{
    os << st.str;
    return os; 
}
 
    // quick and dirty String input
istream & operator>>(istream & is, String & st)
{
    char temp[String::CINLIM];
    is.get(temp, String::CINLIM);
    if (is)
        st = temp;
    while (is && is.get() != '\n')
        continue;
    return is; 
}
 
String operator+(const char *a, const String & b)
{
    String temp;
    delete[] temp.str;
    temp.len = strlen(a) + b.len;
    temp.str = new char[temp.len + 1];
    strcat(strcpy(temp.str, a), b.str);
    return temp;
}
String operator+(const String &a, const String & b) 
{
    String temp;
    delete temp.str;
    temp.len = strlen(a.str) + strlen(b.str);
    temp.str = new char[temp.len + 1];
    strcat(strcpy(temp.str,a.str), b.str);
    return temp;
}
 
void String::stringup() {
    int i = 0;
    while (str[i] != '\0')
    {
        if (islower(str[i]))
            str[i] = toupper(str[i]);
        i++;
    }
}
 
int String::has(char a) {
    strlen(str);
    int b = 0;
    for (int i = 0; i < strlen(str); i++) {
        if (str[i] == a)
            b++;
        }   
    return b;
}
void String::stringlow() {
    int i = 0;
    while (str[i] != '\0')
    {
        if (isupper(str[i]))
            str[i] = tolower(str[i]);
        i++;
    }
}

#include <iostream>
using namespace std;
#include "string1.h"
int main() {
    String s1(" and I am a C++ student");
    String s2 = "Please enter your name: ";// ввод имени
    String s3;
    cout << s2;   // перегруженная операция <<
    cin >> s3;  // перегруженная операция >>
    s2 = "My name is " + s3;
    cout << s2 << ".\n";
    s2 = s2 + s1;
    
    s2.stringup(); // преобразование строки в верхний регистр
    
        cout << "The string \n" << s2 << "\ncontains " << s2.has('A')
        << " 'A' characters in it.\n";
    s1 = "red"; 
    String rgb[3] = { String(s1), String("green"), String("blue"), };
    cout << "Enter the name of a primary color for mixing light: "; // ввод цвета
    String ans;
    bool success = false;
    while (cin >> ans) {
        ans.stringlow(); // преобразование строки в нижний регистр
        for (int i = 0; i < 3; i++) {
            if (ans == rgb[i]) {            
                cout << "That's right! \n";
                success = true;
                break;
            }
        }
 
        if (success)
            break;
        else
            cout << "Try again!" << endl;
    }
        cout << "Bye!" << endl; 
        return 0;
 
}

#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
 
class Cd {
    char perfomance[50];
    char label[20];
    int selections;
    double playtime;
public:
    Cd(char * s1, char *s2, int n, double x);
    Cd(const Cd &d);
    Cd();
    ~Cd() {};
    virtual void Report() const;
    Cd & operator= (const Cd & d);
};
class Classic : public Cd
{
    char nameSong[50];
public:
    Classic() { Cd::Cd(); nameSong[0] = '\0'; }
    Classic(char*name, char *p, char *l, int s, double pl);
    Classic(const char * n, const Cd & rs);
    void Report() const;
};

#include "test.h"
Cd::Cd(char * s1, char *s2, int n, double x) {
    strcpy(perfomance, s1);
    strcpy(label, s2);
    selections = n;
    playtime = x;
}
 
Cd::Cd(const Cd &d) {
    strcpy(perfomance, d.perfomance);
    strcpy(label, d.label);
    selections = d.selections;
    playtime = d.playtime;
}
Cd::Cd() {
    perfomance[0] = '\0';
    label[0] = '\0';
    selections = 0;
    playtime = 0;
}
void Cd::Report()const {
    using std::cout;
    using std::endl;
    cout << "perfomance: " << perfomance << endl;
    cout << "label: " << label << endl;
    cout << "selections: " << selections << endl;
    cout << "playtime: " << playtime << endl;
}
 
Cd & Cd::operator= (const Cd & d) {
    strcpy(perfomance, d.perfomance);
    strcpy(label, d.label);
    selections = d.selections;
    playtime = d.playtime;
    return *this;
}
 
Classic::Classic(char*name, char *p, char *l, int s, double pl) :Cd(p, l, s, pl) {
    strcpy(nameSong, name);
}
Classic::Classic(const char * n, const Cd & rs) :Cd(rs) {
    strcpy(nameSong, n);
}
void Classic:: Report() const {
    using std::cout;
    using std::endl;
    Cd::Report();
    cout << "Main Song: " << nameSong << endl;
}

#include <iostream>
using namespace std;
#include "test.h"
void Bravo(const Cd & disk);
int main() {
    Cd c1("Beatles", "Capitol", 14, 35.5);
    Classic c2 = Classic("Piano Sonata in B flat, Fantasia in C",
        "Alfred Brendel", "Philips", 2, 57.17);
    Cd *pcd = &c1;
    c1.Report();
    c2.Report();
    cout << "\nusing type cd* pointer to object:\n";
    pcd->Report();
    pcd = &c2;
    pcd->Report();
    cout << "\nCalling a function with a Cd reference argument:\n";
    Bravo(c1);
    Bravo(c2);
    
    cout << "\nTesting assignment: ";
    Classic copy;
    copy = c2;
    copy.Report();
    return 0;
}
void Bravo(const Cd & disk) {
    disk.Report();
}

#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
 
class Cd {
    char* perfomance;
    char* label;
    int selections;
    double playtime;
public:
    Cd(char * s1, char *s2, int n, double x);
    Cd(const Cd &d);
    Cd();
    ~Cd() {
        delete[] perfomance;
        delete[] label;
    };
    virtual void Report() const;
    Cd & operator= (const Cd & d);
};
class Classic : public Cd
{
    char *nameSong;
public:
    Classic() { Cd::Cd(); nameSong = new char[1]; nameSong[0] = '\0'; }
    ~Classic() { delete[] nameSong; }
    Classic(char*name, char *p, char *l, int s, double pl);
    Classic(const char * n, const Cd & rs);
    void Report() const;
    Classic & operator= (const Classic & d);
};

#include "test.h"
Cd::Cd(char * s1, char *s2, int n, double x) {
    
    perfomance = new char[strlen(s1) + 1];
    strcpy(perfomance, s1);
    label = new char[strlen(s2) + 1];
    strcpy(label, s2);
    selections = n;
    playtime = x;
}
 
Cd::Cd(const Cd &d) {
    
    perfomance = new char[strlen(d.perfomance) + 1];
    strcpy(perfomance, d.perfomance);
    label = new char[strlen(d.label) + 1];
    strcpy(label, d.label);
    selections = d.selections;
    playtime = d.playtime;
}
Cd::Cd() {  
    perfomance = new char[1];
    perfomance[0] = '\0';
    label = new char[1];
    label[0] = '\0';
    selections = 0;
    playtime = 0;
}
void Cd::Report()const {
    using std::cout;
    using std::endl;
    cout << "perfomance: " << perfomance << endl;
    cout << "label: " << label << endl;
    cout << "selections: " << selections << endl;
    cout << "playtime: " << playtime << endl;
}
 
Cd & Cd::operator= (const Cd & d) {
    if (this == &d) return *this;
    delete[] perfomance;
    delete[] label;
    perfomance = new char[strlen(d.perfomance) + 1];
    strcpy(perfomance, d.perfomance);
    label = new char[strlen(d.label) + 1];
    strcpy(label, d.label);
    selections = d.selections;
    playtime = d.playtime;
    return *this;
}
Classic & Classic::operator= (const Classic & d) {
    Cd::operator=(d);
    delete[] nameSong;
    nameSong = new char[strlen(d.nameSong) + 1];
    strcpy(nameSong, d.nameSong);
    return *this;
}
Classic::Classic(char*name, char *p, char *l, int s, double pl) :Cd(p, l, s, pl) {
 
    nameSong = new char[strlen(name) + 1];
    strcpy(nameSong, name);
}
Classic::Classic(const char * n, const Cd & rs) :Cd(rs) {
    nameSong = new char[strlen(n) + 1];
    strcpy(nameSong, n);
}
void Classic:: Report() const {
    using std::cout;
    using std::endl;
    Cd::Report();
    cout << "Main Song: " << nameSong << endl;
}

#include <iostream>
using namespace std;
#include "test.h"
 
void Bravo(const Cd & disk);
int main() {
    
        Cd c1("Beatles", "Capitol", 14, 35.5);
        Classic c2 = Classic("Piano Sonata in B flat, Fantasia in C",
            "Alfred Brendel", "Philips", 2, 57.17);
        Cd *pcd = &c1;
        c1.Report();
        c2.Report();
        cout << "\nusing type cd* pointer to object:\n";
        pcd->Report();
        pcd = &c2;
        pcd->Report();
        cout << "\nCalling a function with a Cd reference argument:\n";
        Bravo(c1);
        Bravo(c2);
 
        cout << "\nTesting assignment:\n";
        Classic copy;
        copy = c2;
        copy.Report();
        
    return 0;
}
void Bravo(const Cd & disk) {
    disk.Report();
}

#define _CRT_SECURE_NO_WARNINGS
#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); // добавляет b к bottles
    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();
    VintagePort(const char*br, 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);
};

#include "Port.h"
#include <iostream>
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) {
    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) {
    bottles += b;
    return *this;
}
Port&Port::operator-=(int b) {
    bottles -= b;
    return *this;
}
 
void Port::show()const {
    using std::cout;
    using std::endl;
    cout << "Brand: " << brand << endl;
    cout << "Style: " << style << endl;
    cout << "Bottles: " << bottles << endl;
}
ostream & operator<<(ostream & os, const Port &p) {
    os << "Brand: " << p.brand << " ";
    os << "Kind: " << p.style << " ";
    os << "Bottles: " << p.bottles;
    return os;
}
 
VintagePort::VintagePort()  {
    Port::Port();
    nickname = new char[1];
    nickname[0] = '\0';
    int year = 0;
}
 
void VintagePort::show() const {
    Port::show();
    std::cout << "nickname: " << nickname << std::endl;
    std::cout << "year: " << year << std::endl;
}
VintagePort::VintagePort(const char*br, int b, const char *nn, int y): Port(br,"Vintage",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;
    Port::operator=(vp);
    delete[] nickname;
    nickname = new char[strlen(vp.nickname) + 1];
    strcpy(nickname, vp.nickname);
    year = vp.year;
}