How to pass a struct to a class in c++? [closed] - c++

Question

It's difficult to tell what is being asked here. This question is ambiguous, vague, incomplete, overly broad, or rhetorical and cannot be reasonably answered in its current form. For help clarifying this question so that it can be reopened, visit the help center.
Closed 10 years ago.
I am new to c++ and this one has me stumped. I want to pass a struct to a class (I know they are technically the same) so the class can access the data in the struct. I don't mind if it is passed as a reference or a copy as there will be no changes to the struct within the class. Having said that a reference would probably be better for performance. I can get it all to work fine if I pass the members of the struct individually but the real version will have about 30 members so passing them individually isn't the best option.
My main cpp:
#include "stdafx.h"
#include "myClass.h"
#include <iostream>
using namespace std;
struct foo
{
int num;
double dbl;
};
int _tmain(int argc, _TCHAR* argv[])
{
foo bar;
bar.dbl=3.14;
bar.num=42;
baz qux(); //bar needs to be passed here
cout<<qux.getSum()<<endl;
return 0;
}
Class header:
using namespace std;
class baz
{
public:
baz(); //This is where type of bar (foo) is declared
void setSum(int, double);
double getSum();
private:
double sum;
};
Class cpp:
#include "stdafx.h"
#include "myClass.h"
#include <iostream>
using namespace std;
baz::baz() //this is where bar is called
{
setSum(bar.num, bar.dbl);
}
void baz::setSum(int num, double dbl)
{
sum=num*dbl;
}
double baz::getSum()
{
return sum;
}
So the nub of the question is, how do I get bar into baz?

Answer 1

Solved, put the struct definition into a separate header and included that where ever it was needed. Then just a simple change to the declaration in the class header and everything works perfectly. I have included the new code (minus the VS code for the benefit of Abyx who seems to find it so offensive) in case anyone else has the same problem.
Main cpp:
#include "myClass.h"
#include "foo.h"
#include <iostream>
using namespace std;
int main(int argc, _TCHAR* argv[])
{
foo bar;
bar.dbl=3.14;
bar.num=42;
baz qux(bar);
cout<<qux.getSum()<<endl;
return 0;
}
foo.h:
struct foo
{
int num;
double dbl;
};
myClass.h:
class baz
{
public:
baz(const struct foo&);
void setSum(int, double);
double getSum();
private:
double sum;
};
myClass.cpp:
#include "myClass.h"
#include "foo.h"
#include <iostream>
using namespace std;
baz::baz(const foo& blah)
{
setSum(blah.num, blah.dbl);
}
void baz::setSum(int num, double dbl)
{
sum=num*dbl;
}
double baz::getSum()
{
return sum;
}

Answer 2

Make additional constructor. Something like that:
baz::baz(const foo& st){
setSum(st);
}
void baz::setSum(const foo& st)
{
setSum(st.num, st.dbl);
}
then you can:
int _tmain(int argc, _TCHAR* argv[])
{
foo bar;
bar.dbl=3.14;
bar.num=42;
baz qux(bar); //bar needs to be passed here
cout<<qux.getSum()<<endl;
return 0;
}

Answer 3

Your main program:
#include "stdafx.h"
#include "myClass.h"
#include <iostream>
using namespace std;
struct foo
{
int num;
double dbl;
};
int _tmain(int argc, _TCHAR* argv[])
{
foo bar;
bar.dbl=3.14;
bar.num=42;
baz qux(); //bar needs to be passed here
cout<<qux.getSum()<<endl;
return 0;
}
Well, stdafx.h is a header that only makes sense if you turn on (or omit to turn off) use of Microsoft precompiled headers, which makes the Visual C++ preprocessor behave in decidedly non-standard ways. So better remove that. Also, _tmain is a Windows 9x support macro, that expands to either a standard main or a Microsoft-specific wmain. So ditch that also. Finally, there's no need for the return 0 at the end of a standard main, because that's the default return value of main. Also, what's that getSum? Do you write e.g. getsin or getcos? Better call it just sum. Then,
#include "myClass.h"
#include <iostream>
using namespace std;
struct foo
{
int num;
double dbl;
};
int main()
{
foo bar;
bar.dbl=3.14;
bar.num=42;
baz qux( bar ); // See how easy it is to pass `bar`
cout<<qux.sum()<<endl;
}
For the baz class header file, DO NOT EVER have using namespace std in the global namespace in a header file. I.e. remove that also. Then,
#pragma once
#include -- relevant header --
class baz
{
private:
double sum_;
public:
baz( foo const& blah ): sum_( blah.whatever + something ) {}
void setSum( int const n, double const v ) { sum_ = n*v; }
double sum() const { return sum_; }
};
Note: #pragma once is a de facto standard, but it's not ISO standard.