Question

我有一组我正在研究Term＆amp; Poly它们都是类模板。目前我在开始使用Poly类之前正在使用Term类。目前我的班级按预期工作。这是它的声明和实现及其实例化。

Poly.h

#ifndef POLY_H
#define POLY_H

#include <iostream>

template<typename Coefficient, typename Exponent>
class Term {
private:
    Coefficient m_coefficient;
    char m_variable;
    Exponent m_exponentValue;
    Term<Coefficient, Exponent>* m_pExponentExpression;

public:
    Term();
    Term( Coefficient coefficient, char variable, 
          Exponent exponentValue = static_cast<Exponent>(1), 
          Term<Coefficient, Exponent>* pExponentExpression = nullptr );

    void display();
}; // Term

template<typename T>
class Poly {
    // TODO:
    // Empty Shell Class
}; // Poly    

#include "Poly.inl"

#endif // POLY_H

Poly.inl

template<typename Coefficient, typename Exponent>
Term<Coefficient, Exponent>::Term() :
m_coefficient( 0 ),
m_variable( ' ' ),
m_exponentValue( 0 ),
m_pExponentExpression( nullptr ) {
} // Term()

template<typename Coefficient, typename Exponent>
Term<Coefficient, Exponent>::Term( Coefficient coefficient, char variable, Exponent exponentValue, Term<Coefficient, Exponent>* pExponentExpression ) :
m_coefficient( coefficient ),
m_variable( variable ),
m_exponentValue( exponentValue ),
m_pExponentExpression( nullptr ) {
    if ( nullptr != pExponentExpression ) {
        // ExponentValue Will Equal One Since 1 Multiplied By Anything Equals Itself
        // 1 * (Expression) = Expression
        m_exponentValue = static_cast<Exponent>( 1 );
        m_pExponentExpression = pExponentExpression;
    } 

} // Term

template<typename Coefficient, typename Exponent>
void Term<Coefficient, Exponent>::display() {

    if ( m_coefficient == static_cast<Coefficient>( 0 ) ) {
        std::cout << "0";
        return;
    }

    if ( m_pExponentExpression ) {
        if ( ( m_pExponentExpression->m_coefficient == static_cast<Coefficient>( 0 ) ) ||
             ( m_exponentValue == static_cast<Exponent>( 0 ) ) ) {
            std::cout << m_coefficient;
            return;
        }
    }

    if ( m_coefficient != static_cast<Coefficient>( 1 ) ) {
        std::cout << m_coefficient;

        if ( nullptr == m_pExponentExpression ) {
            if ( m_exponentValue == static_cast<Exponent>( 1 ) ) {
                std::cout << m_variable; 
            } else {
                std::cout << m_variable << "^" << m_exponentValue;
                return;
            }
        }  else {
            std::cout << m_variable << "^(";
            m_pExponentExpression->display();
            std::cout << ")";
        }
    } else {
        if (nullptr == m_pExponentExpression) {
            if (m_exponentValue == static_cast<Exponent>(1)) {
                std::cout << m_variable;
            }
            else {
                std::cout << m_variable << "^" << m_exponentValue;
                return;
            }
        }
        else {
            std::cout << m_variable << "^(";
            m_pExponentExpression->display();
            std::cout << ")";
        }
    }
} // display

Poly.cpp

#include "Poly.h"

在这里，我演示了它与一些模板实例的使用。我还演示了构造函数的最后两个默认参数是如何工作的目前的情况;如果指向Term＆lt;＆gt;的指针type不为null，传递给构造函数的指数值将默认为1.我可能稍后更改此值，但是考虑到这样的情况：

Term<int,int> expression( 2, 'x' ); // exponent = 1, expression = nullptr
Term<int,int> term( 4, 'x', 3, &expression );

// The reason for defaulting the third param '3' to '1' is this:
// Would the final term expression be 4x^(3+(2x)), 4x^(3(2x)) etc...

如果我决定解析属于术语表达式的运算符的字符，我可以为后者添加更多逻辑。现在介绍这个类的一些用法。

的main.cpp

#include "Poly.h"

int main () {

    // Template Type <int,int>
    Term<int, int> termIIExpression1( 3, 'x', 2 );
    Term<int, int> termIIExpression2( 2, 'x', 1, &termIIExpression1 );
    Term<int, int> termII1( 5, 'y', 1, &termIIExpression2 );

    std::cout << "Using <int,int>" << std::endl;
    std::cout << "Term Expresion 1: ";
    termIIExpression1.display();
    std::cout << std::endl;

    std::cout << "Term Expression 2: ";
    termIIExpression2.display();
    std::cout << std::endl;

    std::cout << "Term 1: ";
    termII1.display();
    std::cout << std::endl << std::endl;

    // Template Type <double,int>
    Term<double,int> termDIExpression1( 2.8, 'y', 3, nullptr );
    Term<double,int> termDIExpression2( 4.2, 'y', 1, &termDIExpression1 );
    Term<double, int> termDI1( 3.14, 'y', 2, &termDIExpression2 );

    std::cout << "Using <double, int>" << std::endl;
    std::cout << "Term Expression 1: ";
    termDIExpression1.display();
    std::cout << std::endl;

    std::cout << "Term Expression 2: ";
    termDIExpression2.display();
    std::cout << std::endl;

    std::cout << "Term 1: ";
    termDI1.display();
    std::cout << std::endl << std::endl;

    return 0;
} // main

既然您已经在工作中看到过这个类，我的问题就变成了：考虑到我使用指向term<typename, typename>类型的指针作为我的最后一个参数作为指数中的另一个可能术语，我将如何能够做到这样的事情：

的main.cpp

#include "Poly.h"

int main() {

    Term<int, int> expression1( 3, 'x', 2 ); // 3x^2
    Term<double, int> term( 3.14, 'y', 1, &expression1 ); // 3.14y^(3x^2)

} // main

如果不能将模板参数从<int, int>推导到<double, int>，则无法生成编译器错误？含义我希望最后一个参数是指向任何有效Term<typename, typename>类型的指针。

修改

我更新了显示功能，以处理如果系数= 1则不会显示的情况;如果系数= 0，则第一级显示将仅显示0，如果这恰好是一个术语表达式，那么该表达式所属的术语将仅显示其系数，因为任何提升到0 = 1的所以。如果我们有3x^(0)这将简化为3。

将指向模板类的指针传递到同一模板类的构造函数

0 个答案: