Program that uses struct in c plus plus?

Answer 1

C++ of course uses classes (class) as opposed to structures (struct) for the purpose of keeping data members with an implicit 'private' access specifer as opposed to data members being 'public' by default (as with a struct.) Unless use of external C libs or routines are mandatory and wrapped in the appropriate C header(s), I don't know of any reason to use a struct anywhere in C++.

Answer 2

#iostream

struct structure

{

int* p;

};

int main()

{

structure s;

s.p = new int (42);

// use s...

delete s.p;

}

Note that this is poor design. Ownership of the memory pointed to by p is, at best, unclear. We might forget to release the resource before s falls from scope (creating a memory leak) or we might assign another address to p without checking the current address (potentially creating a memory leak) or we might copy the address (potentially deleting the same memory twice).

The best way of avoiding such problems is to not use raw pointers. Indeed, it would be better if we didn't use a structure to store pointers in the first place. Structures should really only be used for POD types (plain old data). That is, a type (class or struct) that has trivial (default) construction, no member functions and entirely public data. However, when working with C code, we will often encounter structures with pointers because C has no concept of classes, thus all C structures can be regarded as being PODs.

If we must use a POD containing a pointer, consider creating a separate class to encapsulate the POD properly, and always move or at least deep copy pointers to acquire any resources that were allocated outwith the class. Raw pointers should always be encapsulated by smart pointers or resource handles. In this way, ownership of the resource falls to the resource handle thus when the handle falls from scope it takes the resource with it. If a resource has shared ownership, then use a shared smart pointer -- the resource will be released when all (strong) references to the resource fall from scope. Raw pointers should always be considered weak references.

Answer 3

The following example program declares a class with 4 constructors. Each constructor initialises the member data and then prints a message, thus confirming which constructor was invoked. The main function exercises each constructor in turn.

#include<iostream>

class X

{

friend std::ostream& operator<< (std::ostream&, const X&);

private:

double m_data;

public:

X (): m_data(0) {

std::cout << "default constructor " << *this << std::endl;

}

X (const double data): m_data(data) {

std::cout << "overloaded constructor #1 " << *this << std::endl;

}

X (const int data): m_data(data) {

std::cout << "overloaded constructor #2 " << *this << std::endl;

}

X (const X& x): m_data(x.m_data) {

std::cout << "copy constructor " << *this << std::endl;

}

};

std::ostream& operator<< (std::ostream& os, const X& x) {

std::cout << "m_data = " << x.m_data;

return os;

}

int main() {

// exercise each constructor in turn

X a;

X b(3.14);

X c(42);

X d(c); // alternatively, X d = c;

}

Note that the default constructor and the overloaded constructor #1 can be combined into a single constructor (an overloaded default constructor) simply by including a default value for the argument:

X (const double data = 0): m_data(data) { ... }

It should also be noted that the compiler will automatically generate a default constructor and a copy constructor if you do not declare any constructors of your own. If you declare any constructor, you will lose the compiler-generated default constructor but retain the compiler-generated copy constructor.

The compiler-generated constructors are implemented exactly as shown above, using a member-wise copy in the copy constructor. Often these are adequate and do not need to be explicitly declared. However, if your class data includes a pointer to unshared memory, you must declare your own copy constructor to ensure the pointer is deep-copied. If you do not, only the pointer itself is copied, which will result in two objects pointing to the same memory rather than copies of that memory. This creates a problem when one object falls from scope, as the destructor must release the memory being pointed to, thus leaving the other object's pointer in an invalid state (pointing at memory that has since been released).

The following example demonstrates how the deep-copy method works in the GOOD copy constructor, and how the shallow copy fails in the BAD copy constructor.

#include<iostream>

class GOOD {

friend std::ostream& operator<< (std::ostream&, const GOOD&);

private:

int * m_data; // pointer to int

public:

GOOD (const int data = 0): m_data(new int(data)) {}

GOOD (const GOOD& good): m_data(new int(*good.m_data)) {} // deep copy

~GOOD() { delete m_data; }

};

std::ostream& operator<< (std::ostream& os, const GOOD& good) {

std::cout << "m_data = " << *good.m_data << " @ address: 0x" << good.m_data;

return os;

}

class BAD {

friend std::ostream& operator<< (std::ostream&, const BAD&);

private:

int * m_data; // pointer to int

public:

BAD (): m_data(new int(0)) {}

BAD (const BAD& bad): m_data(bad.m_data) {} // shallow copy

~BAD() { delete m_data; }

};

std::ostream& operator<< (std::ostream& os, const BAD& bad) {

std::cout << "m_data = " << *bad.m_data << " @ address: 0x" << bad.m_data;

return os;

}

int main() {

GOOD* a = new GOOD(42);

GOOD* b = new GOOD(*a);

std::cout << *a << std::endl;

std::cout << *b << std::endl;

delete a; // b->m_data is still valid

std::cout << *b << std::endl;

delete b;

BAD* c = new BAD;

BAD* d = new BAD(*c);

std::cout << *c << std::endl;

std::cout << *d << std::endl;

delete c; // d->m_data is no longer valid

std::cout << *d << std::endl; // ERROR!

delete d;

}

Answer 4

In C Programming, a Struct is a record type that combines a set of labeled objects into a single object, including objects of different types. You can learn more about the Struct parameter from the Wikipedia website.