C++

Forum

 
I'm getting something weird

Pages: 12
rjryan94 (57)
I'm supposed to get this:
Testing the FullAdder class.

c_in a b c_out s
-----------+---------
0 0 0 | 0 0
0 0 1 | 0 1
0 1 0 | 0 1
0 1 1 | 1 0
1 0 0 | 0 1
1 0 1 | 1 0
1 1 0 | 1 0
1 1 1 | 1 1

But I'm getting:
Testing the FullAdder class.

c_in a b c_out s
-----------+---------
0 0 0 | -858993460 -858993460
0 0 1 | -858993460 -858993460
0 1 0 | -858993460 -858993460
0 1 1 | -858993460 -858993460
1 0 0 | -858993460 -858993460
1 0 1 | -858993460 -858993460
1 1 0 | -858993460 -858993460
1 1 1 | -858993460 -858993460
rjryan94 (57)
Here's my code:
AndGate.hpp
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
 
#ifndef ANDGATE_HPP
#define ANDGATE_HPP

class AndGate {
public:
	AndGate();
	AndGate(int pInputA, int pInputB);
	int GetOutput();
	void SetInputA(int pInputA);
	void SetInputB(int pInputB);
private:
	void Eval();
	void Init(int pInputA, int pInputB);
	int mInputA;
	int mInputB;
	int mOutput;
};

#endif
rjryan94 (57)
FullAdder.hpp
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
 
#ifndef FULLADDER_HPP
#define FULLADDER_HPP

#include "AndGate.hpp"
#include "OrGate.hpp"
#include "XorGate.hpp"

class FullAdder
{
public:
    FullAdder();
    FullAdder(int pInputA, int pInputB, int pInputC);
    int GetOutputC();
    int GetOutputS();
    void SetInputA(int pInputA);
    void SetInputB(int pInputB);
    void SetInputC(int pInputC);
private:
    void Eval();
    void Init(int pInputA, int pInputB, int pInputC);
    AndGate mAnd1;
    AndGate mAnd2;
    int mInputA;
    int mInputB;
    int mInputC;
    OrGate mOr;
    int mOutputC;
    int mOutputS;
    XorGate mXor1;
    XorGate mXor2;
};

#endif
rjryan94 (57)
FullAdderTest.hpp
1
2
3
4
5
6
7
8
9
10
11
 
#ifndef FULLADDERTEST_HPP
#define FULLADDERTEST_HPP

class FullAdderTest
{
public:
    FullAdderTest();
    void Run();
};

#endif
rjryan94 (57)
OrGate.hpp
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
 
#ifndef ORGATE_HPP
#define ORGATE_HPP

class OrGate
{
public:
    OrGate();
    OrGate(int pInputA, int pInputB);
    int GetOutput();
    void SetInputA(int pInputA);
    void SetInputB(int pInputB);
private:
    void Eval();
    void Init(int pInputA, int pInputB);
    int mInputA;
    int mInputB;
    int mOutput;
};

#endif
rjryan94 (57)
XorGate.hpp
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
 
#ifndef XORGATE_HPP
#define XORGATE_HPP

class XorGate
{
public:
    XorGate();
    XorGate(int pInputA, int pInputB);
    int GetOutput();
    void SetInputA(int pInputA);
    void SetInputB(int pInputB);
private:
    void Eval();
    void Init(int pInputA, int pInputB);
    int mInputA;
    int mInputB;
    int mOutput;
};


#endif

rjryan94 (57)
AndGate.cpp
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
 
#include "AndGate.hpp"

AndGate::AndGate()
{
	Init(0, 0);
}

AndGate::AndGate(int pInputA, int pInputB)
{
	Init(pInputA, pInputB);
}

void AndGate::Eval()
{
	mOutput = mInputA & mInputB;
}

int AndGate::GetOutput()
{
	return mOutput;
}

void AndGate::Init(int pInputA, int pInputB)
{
	SetInputA(pInputA);
	SetInputB(pInputB);
}

void AndGate::SetInputA(int pInputA)
{
	mInputA = pInputA;
	Eval();
}

void AndGate::SetInputB(int pInputB)
{
	mInputB = pInputB;
	Eval();
}
rjryan94 (57)
FullAdder.cpp (This is where is most likely coming from)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
 
#include "FullAdder.hpp"

FullAdder::FullAdder()
{
    Init(0, 0, 0);
}

FullAdder::FullAdder(int pInputA, int pInputB, int pInputC)
{
    Init(pInputA, pInputB, pInputC);
}

void FullAdder::Eval()
{
    mXor1.SetInputA(mInputA);
    mXor1.SetInputB(mInputB);
    mXor2.SetInputA(mXor1.GetOutput());
    mXor2.SetInputB(mInputC);
    mAnd1.SetInputA(mXor1.GetOutput());
    mAnd1.SetInputB(mInputC);
    mAnd2.SetInputA(mInputA);
    mAnd2.SetInputB(mInputB);
    mOr.SetInputA(mAnd1.GetOutput());
    mOr.SetInputB(mAnd2.GetOutput());
    mOutputC = mOr.GetOutput();
    mOutputS = mXor2.GetOutput();
}

int FullAdder::GetOutputC()
{
    return mOutputC;
}

int FullAdder::GetOutputS()
{
    return mOutputS;
}

void FullAdder::Init(int pInputA, int pInputB, int pInputC)
{
    mInputA = pInputA;
    mInputB = pInputB;
    mInputC = pInputC;
}

void FullAdder::SetInputA(int pInputA)
{
    mInputA = pInputA;
    Eval();
}

void FullAdder::SetInputB(int pInputB)
{
    mInputB = pInputB;
    Eval();
}

void FullAdder::SetInputC(int pInputC)
{
    mInputC = pInputC;
    Eval();
}

Last edited on
rjryan94 (57)
FullAdderTest.cpp
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
 
#include <iostream>
#include "FullAdder.hpp"
#include "FullAdderTest.hpp"

using namespace std;

FullAdderTest::FullAdderTest()
{
}

void FullAdderTest::Run()
{
    cout << "Testing the FullAdder class" << endl;
    cout << "c_in  a  b   c_out  s" << endl;
    cout << "-----------+---------" << endl;
    for (int inputC = 0; inputC <= 1; inputC++)
    {
        for (int inputA = 0; inputA <= 1; inputA++)
        {
            for (int inputB = 0; inputB <= 1; inputB++)
            {
                FullAdder adder;
                adder.FullAdder::FullAdder(inputA, inputB, inputC);
                cout << "   " << inputC << "  " << inputA << "  " << inputB << " |     ";
                cout << adder.GetOutputC() << "  " << adder.GetOutputS() << endl;
            }
        }
    }
}
rjryan94 (57)
Lab11.cpp
1
2
3
4
5
6
7
8
9
 
#include "FullAdderTest.hpp"

int main()
{
    FullAdderTest test;
    test.FullAdderTest::FullAdderTest();
    test.Run();
    return 0;
}
rjryan94 (57)
OrGate.cpp
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
 
#include "OrGate.hpp"

OrGate::OrGate()
{
	Init(0, 0);
}

OrGate::OrGate(int pInputA, int pInputB)
{
	Init(pInputA, pInputB);
}

void OrGate::Eval()
{
	mOutput = mInputA | mInputB;
}

int OrGate::GetOutput()
{
	return mOutput;
}

void OrGate::Init(int pInputA, int pInputB)
{
	SetInputA(pInputA);
	SetInputB(pInputB);
}

void OrGate::SetInputA(int pInputA)
{
	mInputA = pInputA;
	Eval();
}

void OrGate::SetInputB(int pInputB)
{
	mInputB = pInputB;
	Eval();
}
rjryan94 (57)
XorGate.cpp
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
 
#include "XorGate.hpp"

XorGate::XorGate()
{
	Init(0, 0);
}

XorGate::XorGate(int pInputA, int pInputB)
{
	Init(pInputA, pInputB);
}

void XorGate::Eval()
{
	mOutput = mInputA ^ mInputB;
}

int XorGate::GetOutput()
{
	return mOutput;
}

void XorGate::Init(int pInputA, int pInputB)
{
	SetInputA(pInputA);
	SetInputB(pInputB);
}

void XorGate::SetInputA(int pInputA)
{
	mInputA = pInputA;
	Eval();
}

void XorGate::SetInputB(int pInputB)
{
	mInputB = pInputB;
	Eval();
}
FSchwartz (25)
What sets the values of FullAddr::mOutputC and FullAddr::mOutputS? You are seeing their uninitialized values.
Last edited on
rjryan94 (57)
So how do I fixed it? I need it fixed by Sunday.
Last edited on
Ispil (788)
You need to actually assign a value to mOutputC and mOutputS. Otherwise, you'll just get a random number.
rjryan94 (57)
Can you at least give me hints on how to do it?
giblit (3750)
not sure how you wrote that c++ code without knowing how to assign a value to any variable...
http://en.wikipedia.org/wiki/Assignment_operator_(C%2B%2B)

(try the = sign aka assignment operator)
rjryan94 (57)
How am I not doing it?

1
2
 
mOutputC = mOr.GetOutput();
mOutputS = mXor2.GetOutput();


I need to set mOutputC to the output from mOr and mOutputS to the output from mXor2.
Last edited on
rjryan94 (57)
I need it fixed by Sunday morning.
Last edited on
cire (8284)
1
2
3
4
5
6
7
 
int main()
{
    FullAdderTest test;
    test.FullAdderTest::FullAdderTest();
    test.Run();
    return 0;
}


In this code, line 4 does nothing. Removing it will have no effect on your program. The constructor is called on line 3.

You make similar mistakes throughout your code.
Pages: 12