//somewhere an object is defined
MyClass t = MyClass(...);
//here's functions that operates on MyClass
void doStuffWithTable1(MyClass* t) {
...
...
}
// OR
void doStuffWithTable2(MyClass& t) {
...
...
}
//foo.h
...
std:vector<MyClass> classes;
...
//foo.cpp
...
Foo::Foo() {
for(int i = 0; i < n; i++) {
MyClass t(...);
//do stuff with t
classes.push_back(t);
}
}
...
Quote:Original post by Ariste
1) Use references instead of pointers when you can. They're (almost) guaranteed to be valid. Use pointers when you need the ability to pass NULL. Also, use const MyClass* and const MyClass& if you don't want to change the parameter inside the function.
2) Sure, why not? As long as MyClass copies correctly, that code should be fine.
Quote:Original post by GammenonQuote:Original post by Ariste
1) Use references instead of pointers when you can. They're (almost) guaranteed to be valid. Use pointers when you need the ability to pass NULL. Also, use const MyClass* and const MyClass& if you don't want to change the parameter inside the function.
2) Sure, why not? As long as MyClass copies correctly, that code should be fine.
IIRC const MyClass * was trickier, was not something like const MyClass *const varName?
Quote:Original post by TheUnbelieverQuote:Original post by GammenonQuote:Original post by Ariste
1) Use references instead of pointers when you can. They're (almost) guaranteed to be valid. Use pointers when you need the ability to pass NULL. Also, use const MyClass* and const MyClass& if you don't want to change the parameter inside the function.
2) Sure, why not? As long as MyClass copies correctly, that code should be fine.
IIRC const MyClass * was trickier, was not something like const MyClass *const varName?
No.
const T* is a pointer to const T. You can change the pointer (to point to a different object, to null) but not the pointee.
const T* const is a const pointer to const T. You can change neither the pointer nor the pointee.
const T* const is roughly equivalent to const T&.
Quote:Original post by GammenonQuote:Original post by TheUnbeliever
<snip>
No.
const T* is a pointer to const T. You can change the pointer (to point to a different object, to null) but not the pointee.
const T* const is a const pointer to const T. You can change neither the pointer nor the pointee.
const T* const is roughly equivalent to const T&.
If I have a const T*, I can call some not-const function, but with const & I cannot. Am I wrong?
Quote:Original post by Niux
1. Which is the better solution and why?
void MyClass::doStuffWith() { ... ...}Quote:
2. Will this work? Why not and how to do it right?
Quote:Will classes after this for-loop, contain n instances of MyClass?
Quote:
Yes; that's what .push_back() is for.
Myclass t(...)Quote:
However, do you really need to "do stuff with t" before putting it into the vector? What is "stuff" here?
class MyClass {public: MyClass(); virtual ~MyClass();private: MyOtherClass o;};o = MyOtherClass(...);Quote:Original post by Niux
what I wanted to find out, was whether .push_back() would only put the reference in the vector and not copy the object.
Quote:Original post by Niux
since classes is a vector of MyClass and not MyClass references.
Quote:Original post by Niux
I noticed that the default (MyOtherClass(void)) constructor is automatically called.
MyClass() : o(...) // <--- initialization list{ // constructor body}