Question

我的main.cpp就像这样：

#include <iostream>

#include "curve1.h"
#include "curve2.h"

using namespace std;

int main()
{
    Curve1 curve1Obj;
    Curve2 curve2Obj;

    curve1Obj.enterScores();

    curve1Obj.calcAverage();

    curve1Obj.output();

    curve1Obj.curve();

    curve1Obj.output(curve1Obj.new_getAverage1(), curve1Obj.new_getScore1());

    curve2Obj.curve();

    return 0;
}

基类Score有两个派生类Curve1和Curve2。有两个curve()个函数，一个在Curve1中，另一个在Curve2个类中。 getSize()返回iSize的值。

我的基类标题score.h如下所示：

#ifndef SCORE_H
#define SCORE_H

class Score 
{

private:

    int *ipScore;
    float fAverage;
    int iSize;

public:

    Score(

    void enterScores();
        void calcAverage();
        void output();
    void output(float, int*);

    void setSize();
    int getSize();

    void setScore();
    int *getScore();

    float getAverage();
};

#endif

您可以看到我使用curve1Obj输入分数，计算平均值和输出值。因此，如果我使用getSize()调用cuve1Obj函数，则会在enterScores()函数中为用户提供正确的大小。如果我在getSize()定义文件中调用任何函数中的score.cpp（显然），结果也是一样的。 ..... 问题是当我使用对象curve()在主（第23行）中调用Curve2类的curve2Obj函数时，它会创建一组新的{{1}带垃圾值的}}，ipScore和fAverage （我认为？）。因此，当我在iSize中的getSize()定义中调用curve()时，它会输出垃圾。 ..... 如何使其返回curve2.cpp中设置的旧值？

这是我的curve1.cpp

curve2.cpp

我可以使用函数简单地将值从旧变量放到新变量吗？如果是，那么如何？

Answer 1

此处提供的信息有限，但我会说您的分数构造函数尚未初始化ipScore或iSize。

如果你仍然倾向于使用指向动态分配的int数组的指针，那么至少会使构造函数中的指针无效并在平均函数中测试null（即尚未得分）。

更好的是......为你的分数使用一个std :: vector of int。

为什么人们仍在使用new和delete？他们到底在学校教什么？

我认为你想要的是：

#include <vector>

class Score {
public:
    Score()
    : _scores()
    , _average(0)
    { }

    void calcAverage() {
        double total = 0;
        if(auto s = _scores.size() > 0) {
            for (const auto& v : _scores)
                total += v;
            total /= s;
        }
        _average = total;
    }

    virtual void curve() = 0;

protected:
    // one of the few correct uses of 'protected' - giving limited access to data as interface to derived classes
    const std::vector<double>& scores() const {
        return _scores;
    }

    // or
    std::vector<double> copyScores() const {
        return _scores;
    }

private:
    // use doubles since you'll be doing floating point arithmetic
    std::vector<double> _scores;    
    double _average;
};

class Curve1 : public Score {
public:
    virtual void curve() override {
        // custom curve function here
        // written in terms of scores() or copyScores() if you want to make changes to the array
    }    
};

class Curve2 : public Score {
public:
    virtual void curve() override {
        // custom curve function here
        // written in terms of scores();
    }    
};

Answer 2

你需要了解继承。 Curve1继承自Score。 Curve2继承自Score。

现在看这个例子：

#include <iostream>

class Base {
  int x;
};

class A : public Base {
  int a;
 public:
  void set_a(int arg) {
    a = arg;
  }
  int get_a() {
    return a;
  }
};

class B : public Base {
  int b;
 public:
  void set_b(int arg) {
    b = arg;
  }
  int get_b() {
    return b;
  }
};

int main() {
  A a_object;
  a_object.set_a(4);

  B b_object;
  b_object.set_b(a_object.get_a());

  std::cout << "a of a_object = " << a_object.get_a() << "\n";
  std::cout << "b of b_object = " << b_object.get_b() << "\n";

  return 0;
}

A类，有成员x和a。 B类具有成员x和b。当我创建一个A类实例时，我将在内部创建两个数据成员，x和a。当我创建A类的实例时，我将在内部创建两个数据成员x和b。但是，第一个x和第二个是不同的。它们是记忆中不同的细胞！

Answer 3

类似的东西：

class Score {
public:
    Score()
    : _scores(0)
    , _size(0)
    , _average(0)
    { }

    // copy constructor
    Score(const Score& rhs)
    : _scores( new double[rhs._size] )
    , _size(rhs._size)
    , _average(rhs._average)
    {
        if (_size) {
            for(int i = 0 ; i < _size ; ++i) {
                _scores[i] = rhs._scores[i];
            }
        }
    }

    // ... and if copy constructor then always a copy operator

    Score& operator=(const Score& rhs) {
        // assignment in terms of copy constructor - don't repeat yourself
        Score tmp(rhs);
        swap(tmp);
        return *this;
    }

    // pre c++11 we make our own swap. 
    // post c++11 we would make non-throwing move constructor and move-assignment operator

    void swap(Score& rhs) {
        // std::swap is guaranteed not to throw
        std::swap(_scores, rhs._scores);
        std::swap(_size, rhs._size);
        std::swap(_average, rhs._average);
    }

    ~Score()
    {
        delete[] _scores;
    }

    void calcAverage() {
        double total = 0;
        if(_size > 0) {
            for (int i = 0 ; i < _size ; ++i)
                total += _scores[i];
            total /= _size;
        }
        _average = total;
    }

    virtual void curve() {};

private:
    // use doubles since you'll be doing floating point arithmetic
    double * _scores;    
    int _size;
    double _average;
};

// rmember to override the copy operators and assignment operators of derived classes
// remember to call the base class's operator

Answer 4

好吧，基本上你的问题不能轻易解决。就像你说的那样：

1 - 不要使用任何类型的构造函数。 2 - 不要使用向量。 3 - 使用动态新建和删除等等。

使用构造函数或坚持使用G. Samaras和Richard Hodges所说的内容。你只能这样解决。

如何通过一个派生类的对象将基类私有中设置的值传递给另一个派生类的对象？

4 个答案: