default-constructor

To be more explicit, I get a compile time error when I try accessing an instance variable when I create an object using (), but when I don't, the code compiles and runs as expected. Also, this problem only applies to the default constructor. I would like to understand why. using namespace std; #include <iostream> class Student { public: int gpa; Student() { gpa = 4; } Student( int x ) { gpa = x; } }; int main() { Student zero; Student sally( 2 ); Student jack(); cout << zero.gpa << endl; //prints 4 cout << sally.gpa << endl; // prints 2 cout << jack.gpa << endl; //error: request for member

A "Singular Iterator" is defined as an: iterators that are not associated with any sequence. A null pointer, as well as a default-constructed pointer (holding an indeterminate value) is singular My question 1 would be: Is a default constructed iterator considered a "Singular Iterator"? Secondly, I have been told here that: Results of most expressions are undefined for singular values; the only exceptions are destroying an iterator that holds a singular value, the assignment of a non-singular value to an iterator that holds a singular value, and, for iterators that satisfy the

It's possible that someone has already asked about this but googling for "default", "defaulted", "explicit" and so on doesn't give good results. But anyway. I already know there are some differences between an explicitly defined default construtor (i.e. without arguments) and an explicitly defined defaulted constructor (i.e. with the keyword default ), from here: The new keyword =default in C++11 But what are the differences between an explicitly defined defaulted constructor and implicitly defined one (i.e. when the user doesn't write it at all)? class A { public: A() = default; // other

I have the following class: class Tileset { //base class public: static std::vector<Tileset*> list; virtual ~Tileset() = 0; protected: std::vector<Tile> tiles_list; sf::Texture sheet; private: //non copiable Tileset(const Tileset&); Tileset& operator=(const Tileset&); }; where sf::Texture has a default constructor From my understanding a default constructor should be generated since every member can be default-constructed too. Yet I have a compiler error when I try to construct a derived object without calling a Tileset constructor. Can someone explain why no default constructor is generated?

Suppose I have a class A without a default constructor, a factory method factoryA that returns an object of type A, and a class B that has A as its member. I know that in this case the member of type A of B has to be initialize in B's constructor initialization list. It is not entirely clear to me why so if someone could explain that to me it would be great. Also, what if the parameter to A's constructor needs to be computed inside of B's constructor, say by querying a database or something of that nature? Is there a way to use the setup below without providing A with a default constructor?

If we say that the default constructor is that constructor without parameters, can we also say the the constructor created by the compiler is also a default constructor ? Thanks. Cheers and hth. - Alf A default constructor is one that can be called without arguments. C++98 §12.1/5 : A default constructor for a class X is a constructor of X that can be called without an argument. If there is no user-declared constructor for class X , a default constructor is implicitly declared. The default constructor is a constructor that may be called without arguments. So this is either a constructor that

I ran into a problem because std::is_trivially_default_constructible<std::pair<T1,T2>>::value == false; even if std::is_trivially_default_constructible<T1>::value == true; std::is_trivially_default_constructible<T2>::value == true; I failed to find a good reason for this design. Wouldn't it appropriate for std::pair<T1,T2> to have a =default constructor if T1 and T2 have? Is there a simple work around (simpler than defining my own pair<> )? The simple reason is: history! The original std::pair<T0, T1> couldn't have a trivial default constructor as it had some other constructor. It was defined

These are my class definitions: class Foo{ int _ent; public: void printEnt() const{cout << _ent << ' ';} }; class Bar{ Foo _foo; public: void printEnt() const{_foo.printEnt();} }; And this is my test code: char* buf = new char[sizeof(Foo) + sizeof(Foo) + sizeof(Bar)]; fill(buf, buf + sizeof(Foo) + sizeof(Foo) + sizeof(Bar), 'J'); cout << ((int*)buf)[0] << ' ' << ((int*)buf)[1] << ' ' << ((int*)buf)[2] << endl; Foo* first = new (buf) Foo; Foo* second = new (buf + sizeof(Foo)) Foo(); Bar* third = new (buf + sizeof(Foo) * 2) Bar; first->printEnt(); second->printEnt(); third->printEnt(); My output