No source file named /home/david/etc... error

I just finished making the compiler happy on a console project and went to run the program, but there's no output and the program exits. The error I get in the console is:

No source file named /home/david/workspace/customerAccounts/customerAccounts.cpp.
No source file named /home/david/workspace/Roster/Roster.cpp.
No source file named /home/david/workspace/customerAccounts/customerAccounts.cpp.
Quit

The funny thing is, the name of the .cpp file is neither customerAccounts nor Roster. Following is the cpp file I'm using:

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
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
// Representation of Complex Numbers

#include <iostream>
using namespace std;

class Complex
{
public:
	Complex();
	Complex(double real__, double imaginary__);
	Complex(const Complex& c2);
	Complex(double init);
	~Complex();
	Complex operator= (Complex rhs);
	Complex operator= (double init);
	Complex operator+ (Complex rhs);
	Complex operator- (Complex rhs);
	Complex operator* (Complex rhs);
	Complex operator/ (double divisr);

	Complex operator+= (Complex rhs);
	Complex operator-= (Complex rhs);
	Complex operator*= (Complex rhs);

	bool operator== (Complex rhs);
	bool operator!= (Complex rhs);

	double real();
	double imaginary();

	void setReal(double rl){*real_ = rl;};
	void setImaginary(double imgnry){*imaginary_ = imgnry;};

	friend ostream& operator<< (std::ostream& ostr, const Complex& z);
	friend Complex operator* (double i,Complex rhs);

private:
	double  *real_;
	double *imaginary_;
};

Complex operator* (double i,Complex rhs)
{
	Complex tmp;
	double rl;
	double imgnry;

	rl = (rhs.real() * i);
	tmp.setReal(rl);

	imgnry = (rhs.imaginary() * i);
	tmp.setImaginary(imgnry);

	return tmp;
}

// ****************Driver ********************
int main()
{
	Complex z;
	Complex x(2.3, 5.6);
	Complex y = 2.1;

	Complex u(y);

	z = x;

	y = z + x;  //    y=(4.6, 11.2)
	z = x - y;  //    z=(-2.3, -5.6)

	u += x;	// u=(4.4, 5.6)

	x= 2.0 * u; // x=(8.8,11.2)

	y= z/2.0;  // y=(-1.15,-2.8)

	cout << "x  = " << x <<endl;
	cout << "y  = " << y <<endl;
	cout << "z  = " << z <<endl;
	return 0;
}

// class implementation
Complex::Complex()
{
	*real_ = 0.0;
	*imaginary_ = 0.0;
}

Complex::Complex(double real__, double imaginary)
{
	*real_ = real__;
	*imaginary_ = 0.0;
}

Complex::Complex(const Complex& c2)
{
	*real_ = *(c2.real_);
	*imaginary_ = *(c2.imaginary_);
}

Complex::Complex(double init)
{
	*real_ = init;
	*imaginary_ = 0.0;
}

Complex::~Complex()
{
}

Complex Complex::operator= (Complex rhs)
{
	*real_ = *(rhs.real_);
	*imaginary_ = *(rhs.imaginary_);

	return *this;
}

Complex Complex::operator= (double init)
{
	*real_ = init;
	*imaginary_ = 0.0;

	return *this;
}

bool Complex::operator== (Complex rhs)
{
	return (*real_ == rhs.real() && *imaginary_ == rhs.imaginary());
}

bool Complex::operator!= (Complex rhs)
{
	return ! (*this == rhs);
}

Complex Complex::operator+ (Complex rhs)
{
	Complex tmp(*this);
	return tmp += rhs;
}

Complex Complex::operator- (Complex rhs)
{
	Complex tmp(*this);
	return tmp -= rhs;
}

Complex Complex::operator* (Complex rhs)
{
	Complex tmp(*this);
	return tmp *= rhs;
}

Complex Complex::operator/ (double divisr)
{
	Complex tmp(*this);
	double rl;
	double imgnry;
	rl = (tmp.real() / divisr);
	tmp.setReal(rl);
	imgnry = (tmp.imaginary() / divisr);
	tmp.setImaginary(imgnry);
	return tmp;
}

Complex Complex::operator+= (Complex rhs)
{
	*real_ += *(rhs.real_);
	*imaginary_ += *(rhs.imaginary_);

	return *this;
}

Complex Complex::operator-= (Complex rhs)
{
	*real_ -= *(rhs.real_);
	*imaginary_ -= *(rhs.imaginary_);

	return *this;
}


Complex Complex::operator*= (Complex rhs)
{
	*real_ *= *(rhs.real_);
	*imaginary_ *= *(rhs.imaginary_);

	return *this;
}

double Complex::real()
{
	return *real_;
}

double Complex::imaginary()
{
	return *imaginary_;
}

std::ostream& operator<< (std::ostream& ostr, const Complex& z)
{
	return ostr << *z.real_ << " " << *z.imaginary_;
}
Last edited on
I don't understand the customer accounts messages. I think it must be some configuration of your environment which is picking up references from a previous project.

However, I do see a problem here:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
class Complex
{
public:
	Complex();

private:
	double *real_;
	double *imaginary_;
};

Complex::Complex()
{
	*real_ = 0.0;
	*imaginary_ = 0.0;
}

Variables real_ and imaginary_ are uninitialised pointers to type double.
They will contain some random values which happened to be there already.
Then at lines 13 and 14, an attempt is made to write the value 0.0 to these random areas of memory.

If you are lucky, the program will crash with an exception. If you are unlucky, the program will continue to execute, having corrupted some area of memory which it has no right to access, with unpredictable effects at some later stage.

I don't see any reason why these values are pointers and not just variables of type double. But if you have a valid reason for using a pointer, memory must be allocated and the variable initialised to point to that memory.

Preferably just do this:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
class Complex
{
public:
    Complex();

private:
    double real_;
    double imaginary_;
};

Complex::Complex()
{
    real_ = 0.0;
    imaginary_ = 0.0;
}

but if pointers are really needed,
1
2
3
4
5
6
7
8
9
10
11
12
13
Complex::Complex()
{
    real_ = new double;
    imaginary_ = new double;
    *real_ = 0.0;
    *imaginary_ = 0.0;
}

Complex::~Complex()
{
    delete real_;
    delete imaginary_;
}
Last edited on
Thank you so much. Initializing the double pointers made the weird errors disappear, and everything worked like a clock! And yes, the project was to work around the challenge of the private member variables of Complex being pointers. Thanks again!
Topic archived. No new replies allowed.