C++ class question

[pkfox]

Hi and thanks for replying but the problem I have is I don't know the path to my input file until later in the program

"I didn't mention the bats - he'd see them soon enough" - Hunter S Thompson - RIP

[pkfox]

Hi and thanks for replying but the problem I have is I don't know the path to my input file until later in the program

"I didn't mention the bats - he'd see them soon enough" - Hunter S Thompson - RIP

[David Crow]

Then add an empty constructor and a "setter" method to the class.

"One man's wage rise is another man's price increase." - Harold Wilson

"Fireproof doesn't mean the fire will never come. It means when the fire comes that you will be able to withstand it." - Michael Simmons

"You can easily judge the character of a man by how he treats those who can do nothing for him." - James D. Miles

[Mircea Neacsu]

In that case have a default constructor for initialization and add a function BillingDates::Open (std::string& file) that gets called when you have the path to your file. You might also need something like bool BillingDates::IsOpen() const to check the state of the object.

Mircea

[Joe Woodbury]

If they need to be the same instance, versus a copy, consider using std::shared_ptr for both.

[CPallini]

Time to invest some time (pardon the pun) on learning smart pointers. See, for instance unique_ptr, shared_ptr, weak_ptr, scoped_ptr, raw pointers - Knowing your smart pointers (2/7) - Fluent C++[^].

"In testa che avete, Signor di Ceprano?" -- Rigoletto

[Daniel Pfeffer]

In C++, you can define variables at any point, not just at the beginning of the block. Define bData2 only at the point that file name is known.

Freedom is the freedom to say that two plus two make four. If that is granted, all else follows. -- 6079 Smith W.

[pkfox]

Hi there, I don't think I'm explaining what is confusing me so I'll try again. If I define a class object in a C# program I can instantiate it like so Sample of the top of my head code

namespace Test
{
public class Dummy
{
string Path {get;set;}
Public Dummy(string Path)
{
this.Path = Path;
}
}

class Program
{
    Dummy dummy {get;set;}
    \[STAThread\]
    static void Main()
    {
        Program p = new Program();
        p.dummy = new Dummy("MyPath");
    }
}

}

In C++ I can only create it like this if I make the dummy variable a pointer ( which is not a problem but I'd like to know how to do it the other way) I'm sure this must be doable. Thanks for everyones help so far.

"I didn't mention the bats - he'd see them soon enough" - Hunter S Thompson - RIP

[Lost User]

Correcting the mis-spellings you have:

BillingDates *bData; // the class is called BillingDates not BillingData
BillingDates bData2;

In the above code bData is a pointer that has not yet been initialised, so it does not actually point to anything. bData2 is an actual instance of the class, or would be if you had included the no-parameters constructor to get it to compile. But I am not sure what you are trying to do with them. You could add the following line of code at some point:

bData = new BillingDates("someFilename");

but then what? And it is still not clear what bdata2 is supposed to be for.

[pkfox]

Hi Richard, sorry about the spelling mistakes I'm actually working on multiple project so that was a cut'n past jobbie I know I can do this

bData = new BillingDates("someFilename");

but how can I create an instance of the class using bData2 ( not in the declaration of the variable I know how to do that ) as I said earlier in C# ypu can declare like

someclass someclassob {get;set;}

Then create the instance

someclassobj = new someclass("Parameter goes here");

even though you didn't specify a parameter in the declaration of someclassobj .

"I didn't mention the bats - he'd see them soon enough" - Hunter S Thompson - RIP

[Lost User]

pkfox wrote:

ypu can declare like

someclass someclassob {get;set;}

That's a new one on me, I must look it up. As I mentioned you need to add a parameterless constructor to the class, and some method that allows you to add a filename at runtime. something like:

class BillingDates
{
public:
BillingDates();
BillingDates(std::string InputFile);
void addFile(std::string InputFile);
void ProcessDates();
// stuff removed for readability
};
// the implementation of addFile will do the same as the constructor that takes a filename.

You can then write:

BillingDates *bData;
BillingDates bData2;

// and later on something like
bData2.addFile("your file name here");
bData = &bData2;

But I really don't know why you need any of that. All you really need is:

BillingDates *bData;

// and later on something like

bData = new BillingDates("your file name here");

Does that make (any) sense?

[pkfox]

Hi Richard yes it does and in fact is what I'm currently doing - I think I need to take my C# head off - thanks very much for your time

"I didn't mention the bats - he'd see them soon enough" - Hunter S Thompson - RIP

[Lost User]

I do think going backwards from C# to C++ is going to mess with your head quite a lot. Good luck.

[CPallini]

Quote:

which is not a problem but I'd like to know how to do it the other way

There isn't 'the other way' (AFAIK). In C++, using new, you get a pointer. Moreover you need to handle the cleanup of the dynamically allocated memory:

#include using namespace std;

namespace Test {
class Dummy
{
string path;

public:
Dummy(string path) : path {path}{}
string get (){return path;}
void set(string newpath){ path = newpath; }
};

class Program
{
Dummy * dummy;

public:
static void main()
{
Program * p = new Program();
p->dummy = new Dummy("MyPath");

  cout << p->dummy->get() << "\\n";

  // cleanup 
  delete p->dummy;
  delete p;
}

};
} // <- Test

int main()
{
Test::Program::main();
}

You may write the Program destructor to ammeliorate the code, but cleanup is unavoidable. If you can initialize at once your objects then you could use the stack and the code would be nicer:

#include using namespace std;

namespace Test {
class Dummy
{
string path;

public:
Dummy(string path) : path {path}{}
string get (){return path;}
void set(string newpath){ path = newpath; }
};

class Program
{
Dummy dummy;

public:
Program( Dummy dummy):dummy{dummy}{}
static void main()
{
Program p { Dummy{ "MyPath" } };
cout << p.dummy.get() << "\n";

  // no cleanup needed
}

};
} // <- Test

int main()
{
Test::Program::main();
}

Finally smart pointers allows you to make the two steps initiazlization without the hassle of manual cleanup, e.g.

#include #include using namespace std;

namespace Test {
class Dummy
{
string path;

public:
Dummy(string path) : path {path}{}
string get (){return path;}
void set(string newpath){ path = newpath; }
};

class Program
{
unique_ptr dummy;

public:
static void main()
{
Program p {};
p.dummy = make_unique("MyPath");

  cout << p.dummy->get() << "\\n";

  // no cleanup needed
}

};
} // <- Test

int main()
{
Test::Program::main();
}

"In testa che avete, Signor di Ceprano?" -- Rigoletto

[pkfox]

:-D

"I didn't mention the bats - he'd see them soon enough" - Hunter S Thompson - RIP