Related
This question was already asked in the context of C#/.Net.
Now I'd like to learn the differences between a struct and a class in C++. Please discuss the technical differences as well as reasons for choosing one or the other in OO design.
I'll start with an obvious difference:
If you don't specify public: or private:, members of a struct are public by default; members of a class are private by default.
I'm sure there are other differences to be found in the obscure corners of the C++ specification.
You forget the tricky 2nd difference between classes and structs.
Quoth the standard (§11.2.2 in C++98 through C++11):
In absence of an access-specifier
for a base class, public is assumed
when the derived class is declared
struct and private is assumed when the class is declared class.
And just for completeness' sake, the more widely known difference between class and struct is defined in (11.2):
Member of a class defined with the
keyword class are private by
default. Members of a class defined
with the keywords struct or union
are public by default.
Additional difference: the keyword class can be used to declare template parameters, while the struct keyword cannot be so used.
Quoting The C++ FAQ,
[7.8] What's the difference between
the keywords struct and class?
The members and base classes of a
struct are public by default, while in
class, they default to private. Note:
you should make your base classes
explicitly public, private, or
protected, rather than relying on the
defaults.
Struct and class are otherwise
functionally equivalent.
OK, enough of that squeaky clean
techno talk. Emotionally, most
developers make a strong distinction
between a class and a struct. A
struct simply feels like an open pile
of bits with very little in the way of
encapsulation or functionality. A
class feels like a living and
responsible member of society with
intelligent services, a strong
encapsulation barrier, and a well
defined interface. Since that's the
connotation most people already have,
you should probably use the struct
keyword if you have a class that has
very few methods and has public data
(such things do exist in well designed
systems!), but otherwise you should
probably use the class keyword.
It's worth remembering C++'s origins in, and compatibility with, C.
C has structs, it has no concept of encapsulation, so everything is public.
Being public by default is generally considered a bad idea when taking an object-oriented approach, so in making a form of C that is natively conducive to OOP (you can do OO in C, but it won't help you) which was the idea in C++ (originally "C With Classes"), it makes sense to make members private by default.
On the other hand, if Stroustrup had changed the semantics of struct so that its members were private by default, it would have broken compatibility (it is no longer as often true as the standards diverged, but all valid C programs were also valid C++ programs, which had a big effect on giving C++ a foothold).
So a new keyword, class was introduced to be exactly like a struct, but private by default.
If C++ had come from scratch, with no history, then it would probably have only one such keyword. It also probably wouldn't have made the impact it made.
In general, people will tend to use struct when they are doing something like how structs are used in C; public members, no constructor (as long as it isn't in a union, you can have constructors in structs, just like with classes, but people tend not to), no virtual methods, etc. Since languages are as much to communicate with people reading the code as to instruct machines (or else we'd stick with assembly and raw VM opcodes) it's a good idea to stick with that.
Class' members are private by default. Struct's members are public by default. Besides that there are no other differences. Also see this question.
According to Stroustrup in the C++ Programming Language:
Which style you use depends on circumstances and taste. I usually prefer to use struct for classes that have all data public. I think of such classes as "not quite proper types, just data structures."
Functionally, there is no difference other than the public / private
Members of a class are private by default and members of struct are public by default.
For example program 1 fails in compilation and program 2 works fine.
// Program 1
#include <stdio.h>
class Test {
int x; // x is private
};
int main()
{
Test t;
t.x = 20; // compiler error because x is private
getchar();
return 0;
}
// Program 2
#include <stdio.h>
struct Test {
int x; // x is public
};
int main()
{
Test t;
t.x = 20; // works fine because x is public
getchar();
return 0;
}
When deriving a struct from a class/struct, default access-specifier for a base class/struct is public. And when deriving a class, default access specifier is private.
For example program 3 fails in compilation and program 4 works fine.
// Program 3
#include <stdio.h>
class Base {
public:
int x;
};
class Derived : Base { }; // is equivalent to class Derived : private Base {}
int main()
{
Derived d;
d.x = 20; // compiler error because inheritance is private
getchar();
return 0;
}
// Program 4
#include <stdio.h>
class Base {
public:
int x;
};
struct Derived : Base { }; // is equivalent to struct Derived : public Base {}
int main()
{
Derived d;
d.x = 20; // works fine because inheritance is public
getchar();
return 0;
}
STRUCT is a type of Abstract Data Type that divides up a given chunk of memory according to the structure specification. Structs are particularly useful in file serialization/deserialization as the structure can often be written to the file verbatim. (i.e. Obtain a pointer to the struct, use the SIZE macro to compute the number of bytes to copy, then move the data in or out of the struct.)
Classes are a different type of abstract data type that attempt to ensure information hiding. Internally, there can be a variety of machinations, methods, temp variables, state variables. etc. that are all used to present a consistent API to any code which wishes to use the class.
In effect, structs are about data, classes are about code.
However, you do need to understand that these are merely abstractions. It's perfectly possible to create structs that look a lot like classes and classes that look a lot like structs. In fact, the earliest C++ compilers were merely pre-compilers that translates C++ code to C. Thus these abstractions are a benefit to logical thinking, not necessarily an asset to the computer itself.
Beyond the fact that each is a different type of abstraction, Classes provide solutions to the C code naming puzzle. Since you can't have more than one function exposed with the same name, developers used to follow a pattern of _(). e.g. mathlibextreme_max(). By grouping APIs into classes, similar functions (here we call them "methods") can be grouped together and protected from the naming of methods in other classes. This allows the programmer to organize his code better and increase code reuse. In theory, at least.
The only other difference is the default inheritance of classes and structs, which, unsurprisingly, is private and public respectively.
The difference between class and struct is a difference between keywords, not between data types. This two
struct foo : foo_base { int x;};
class bar : bar_base { int x; };
both define a class type. The difference of the keywords in this context is the different default access:
foo::x is public and foo_base is inherited publicly
bar::x is private and bar_base is inherited privately
The members of a structure are public by default, the members of class are private by default.
Default inheritance for Structure from another structure or class is public.Default inheritance for class from another structure or class is private.
class A{
public:
int i;
};
class A2:A{
};
struct A3:A{
};
struct abc{
int i;
};
struct abc2:abc{
};
class abc3:abc{
};
int _tmain(int argc, _TCHAR* argv[])
{
abc2 objabc;
objabc.i = 10;
A3 ob;
ob.i = 10;
//A2 obja; //privately inherited
//obja.i = 10;
//abc3 obss;
//obss.i = 10;
}
This is on VS2005.
Not in the specification, no. The main difference is in programmer expectations when they read your code in 2 years. structs are often assumed to be POD. Structs are also used in template metaprogramming when you're defining a type for purposes other than defining objects.
One other thing to note, if you updated a legacy app that had structs to use classes you might run into the following issue:
Old code has structs, code was cleaned up and these changed to classes.
A virtual function or two was then added to the new updated class.
When virtual functions are in classes then internally the compiler will add extra pointer to the class data to point to the functions.
How this would break old legacy code is if in the old code somewhere the struct was cleared using memfill to clear it all to zeros, this would stomp the extra pointer data as well.
Another main difference is when it comes to Templates. As far as I know, you may use a class when you define a template but NOT a struct.
template<class T> // OK
template<struct T> // ERROR, struct not allowed here
Member of a class defined with the keyword class are private by default. Members of a class defined with the keywords struct (or union) are public by default.
In absence of an access-specifier for a base class, public is assumed when the derived class is declared struct and private is assumed when the class is declared class.
You can use template<class T> but not template<struct T>.
Note also that the C++ standard allows you to forward-declare a type as a struct, and then use class when declaring the type and vice-versa. Also, std::is_class<Y>::value is true for Y being a struct and a class, but is false for an enum class.
Here is a good explanation: http://carcino.gen.nz/tech/cpp/struct_vs_class.php
So, one more time: in C++, a struct is identical to a class except that the members of a struct have public visibility by default, but the members of a class have private visibility by default.
It's just a convention. Structs can be created to hold simple data but later evolve time with the addition of member functions and constructors. On the other hand it's unusual to see anything other than public: access in a struct.
ISO IEC 14882-2003
9 Classes
§3
A structure is a class defined with
the class-key struct; its members
and base classes (clause 10) are
public by default (clause 11).
The other answers have mentioned the private/public defaults, (but note that a struct is a class is a struct; they are not two different items, just two ways of defining the same item).
What might be interesting to note (particularly since the asker is likely to be using MSVC++ since he mentions "unmanaged" C++) is that Visual C++ complains under certain circumstances if a class is declared with class and then defined with struct (or possibly the other way round), although the standard says that is perfectly legal.
. In classes all the members by default are private but in structure
members are public by default.
There is no term like constructor and destructor for structs, but for class compiler creates default if you don't provide.
Sizeof empty structure is 0 Bytes wer as Sizeof empty class is 1 Byte The struct default access type is public. A struct should
typically be used for grouping data.
The class default access type is private, and the default mode for
inheritance is private. A class should be used for grouping data and
methods that operate on that data.
In short, the convention is to use struct when the purpose is to
group data, and use classes when we require data abstraction and,
perhaps inheritance.
In C++ structures and classes are passed by value, unless explicitly
de-referenced. In other languages classes and structures may have
distinct semantics - ie. objects (instances of classes) may be passed
by reference and structures may be passed by value. Note: There are
comments associated with this question. See the discussion page to
add to the conversation.
While implied by other answers, it's not explicitly mentioned - that structs are C compatible, depending on usage; classes are not.
This means if you're writing a header that you want to be C compatible then you've no option other than struct (which in the C world can't have functions; but can have function pointers).
There exists also unwritten rule that tells:
If data members of class have no association with itself, use struct.
If value of data member depends on another value of data member, use class.
f.e
class Time
{
int minutes;
int seconds;
}
struct Sizes
{
int length;
int width;
};
You might consider this for guidelines on when to go for struct or class, https://msdn.microsoft.com/en-us/library/ms229017%28v=vs.110%29.aspx .
√ CONSIDER defining a struct instead of a class if instances of the
type are small and commonly short-lived or are commonly embedded in
other objects.
X AVOID defining a struct unless the type has all of
the following characteristics:
It logically represents a single value,
similar to primitive types (int, double, etc.).
It has an instance
size under 16 bytes.
It is immutable.
It will not have to be boxed
frequently.
The difference between struct and class keywords in C++ is that, when there is no specific specifier on particular composite data type then by default struct or union is the public keywords that merely considers data hiding but class is the private keyword that considers the hiding of program codes or data. Always some programmers use struct for data and class for code sake. For more information contact other sources.
Out of all these factors,it can be concluded that concept Class is highly suitable to represent real world objects rather than "Structures".Largely because OOP concepts used in class are highly practical in explaining real world scenarios therefore easier to merge them to reality.For an example,default inheritance is public for structs but if we apply this rule for real world,it's ridiculous.But in a class default inheritance is private which is more realistic.
Anyways,what i need to justify is Class is a much broader,real world applicable concept whereas Structure is a primitive Concept with poor internal organization(Eventhough struct follows OOP concepts,they have a poor meaning)
Class is only meaningful in the context of software engineering. In the context of data structures and algorithms, class and struct are not that different. There's no any rule restricted that class's member must be referenced.
When developing large project with tons of people without class, you may finally get complicated coupled code because everybody use whatever functions and data they want. class provides permission controls and inherents to enhance decoupling and reusing codes.
If you read some software engineering principles, you'll find most standards can not be implemented easily without class. for example:
http://en.wikipedia.org/wiki/SOLID_%28object-oriented_design%29
BTW, When a struct allocates a crunch of memory and includes several variables, value type variables indicates that values are embbeded in where struct is allocated. In contrast, reference type variable's values are external and reference by a pointer which is also embedded in where struct is allocated.
The main difference between structure and class keyword in oops is that, no public and private member declaration present in structure.and the data member and member function can be defined as public, private as well as protected.
The main difference between struct and class is that in struct you can only declare data variables of different data types while in class you can declare data variables,member functions and thus you can manipulate data variables through functions.
-> another handy thing that i find in class vs struct is that while implementing files in a program if you want to make some operations of a struct again and again on every new set of operations you need to make a separate function and you need to pass object of struct after reading it from the file so as to make some operations on it .
while in class if you make a function that does some operations on the data needed everytime..its easy you just have to read object from file and call the function..
But it depennds on the programmer which way he/she finds suitable...according to me i prefer class everytime just because it supports OOPs and thats the reason it is implemented in almost every languages and its the wonderful feature of all time programming ;-)
And yeah the most unforgotten difference i forgot to mention is that class supports data hiding and also supports operations that are performed on built in data types while struct doesnt !
I found an other difference. if you do not define a constructor in a class, the compiler will define one. but in a struct if you do not define a constructor, the compiler do not define a constructor too. so in some cases that we really do not need a constructor, struct is a better choice (performance tip).
and sorry for my bad English.
Classes are Reference types and Structures are Values types.
When I say Classes are reference types,
basically they will contain the address of an instance variables.
For example:
Class MyClass
{
Public Int DataMember; //By default, accessibility of class data members
//will be private. So I am making it as Public which
//can be accessed outside of the class.
}
In main method,
I can create an instance of this class using new operator that allocates memory for this class
and stores the base address of that into MyClass type variable(_myClassObject2).
Static Public void Main (string[] arg)
{
MyClass _myClassObject1 = new MyClass();
_myClassObject1.DataMember = 10;
MyClass _myClassObject2 = _myClassObject1;
_myClassObject2.DataMember=20;
}
In the above program,
MyClass _myClassObject2 = _myClassObject1;
instruction indicates that both variables of type MyClass
myClassObject1
myClassObject2
and will point to the same memory location.
It basically assigns the same memory location into another variable of same type.
So if any changes that we make in any one of the objects type MyClass will have an effect on another
since both are pointing to the same memory location.
"_myClassObject1.DataMember = 10;" at this line both the object’s data members will contain the value of 10.
"_myClassObject2.DataMember = 20;" at this line both the object’s data member will contains the value of 20.
Eventually, we are accessing datamembers of an object through pointers.
Unlike classes, structures are value types.
For example:
Structure MyStructure
{
Public Int DataMember; //By default, accessibility of Structure data
//members will be private. So I am making it as
//Public which can be accessed out side of the structure.
}
Static Public void Main (string[] arg)
{
MyStructure _myStructObject1 = new MyStructure();
_myStructObject1.DataMember = 10;
MyStructure _myStructObject2 = _myStructObject1;
_myStructObject2.DataMember = 20;
}
In the above program,
instantiating the object of MyStructure type using new operator and
storing address into _myStructObject variable of type MyStructure and
assigning value 10 to data member of the structure using "_myStructObject1.DataMember = 10".
In the next line,
I am declaring another variable _myStructObject2 of type MyStructure and assigning _myStructObject1 into that.
Here .NET C# compiler creates another copy of _myStructureObject1 object and
assigns that memory location into MyStructure variable _myStructObject2.
So whatever change we make on _myStructObject1 will never have an effect on another variable _myStructObject2 of type MyStructrue.
That’s why we are saying Structures are value types.
So the immediate Base class for class is Object and immediate Base class for Structure is ValueType which inherits from Object.
Classes will support an Inheritance whereas Structures won’t.
How are we saying that?
And what is the reason behind that?
The answer is Classes.
It can be abstract, sealed, static, and partial and can’t be Private, Protected and protected internal.
There are 3 basic difference between structure and class
1St- memory are reserved for structure in stack memory (which is near to programming language )whether for class in stack memory are reserved for only reffrence and actual memory are reserved in heap memory.
2Nd - By default structure treat as a public whether class treat as a private .
3Rd- can't re -use code in structure but in class we can re-use same code in many time called inhertence
This question was already asked in the context of C#/.Net.
Now I'd like to learn the differences between a struct and a class in C++. Please discuss the technical differences as well as reasons for choosing one or the other in OO design.
I'll start with an obvious difference:
If you don't specify public: or private:, members of a struct are public by default; members of a class are private by default.
I'm sure there are other differences to be found in the obscure corners of the C++ specification.
You forget the tricky 2nd difference between classes and structs.
Quoth the standard (§11.2.2 in C++98 through C++11):
In absence of an access-specifier
for a base class, public is assumed
when the derived class is declared
struct and private is assumed when the class is declared class.
And just for completeness' sake, the more widely known difference between class and struct is defined in (11.2):
Member of a class defined with the
keyword class are private by
default. Members of a class defined
with the keywords struct or union
are public by default.
Additional difference: the keyword class can be used to declare template parameters, while the struct keyword cannot be so used.
Quoting The C++ FAQ,
[7.8] What's the difference between
the keywords struct and class?
The members and base classes of a
struct are public by default, while in
class, they default to private. Note:
you should make your base classes
explicitly public, private, or
protected, rather than relying on the
defaults.
Struct and class are otherwise
functionally equivalent.
OK, enough of that squeaky clean
techno talk. Emotionally, most
developers make a strong distinction
between a class and a struct. A
struct simply feels like an open pile
of bits with very little in the way of
encapsulation or functionality. A
class feels like a living and
responsible member of society with
intelligent services, a strong
encapsulation barrier, and a well
defined interface. Since that's the
connotation most people already have,
you should probably use the struct
keyword if you have a class that has
very few methods and has public data
(such things do exist in well designed
systems!), but otherwise you should
probably use the class keyword.
It's worth remembering C++'s origins in, and compatibility with, C.
C has structs, it has no concept of encapsulation, so everything is public.
Being public by default is generally considered a bad idea when taking an object-oriented approach, so in making a form of C that is natively conducive to OOP (you can do OO in C, but it won't help you) which was the idea in C++ (originally "C With Classes"), it makes sense to make members private by default.
On the other hand, if Stroustrup had changed the semantics of struct so that its members were private by default, it would have broken compatibility (it is no longer as often true as the standards diverged, but all valid C programs were also valid C++ programs, which had a big effect on giving C++ a foothold).
So a new keyword, class was introduced to be exactly like a struct, but private by default.
If C++ had come from scratch, with no history, then it would probably have only one such keyword. It also probably wouldn't have made the impact it made.
In general, people will tend to use struct when they are doing something like how structs are used in C; public members, no constructor (as long as it isn't in a union, you can have constructors in structs, just like with classes, but people tend not to), no virtual methods, etc. Since languages are as much to communicate with people reading the code as to instruct machines (or else we'd stick with assembly and raw VM opcodes) it's a good idea to stick with that.
Class' members are private by default. Struct's members are public by default. Besides that there are no other differences. Also see this question.
According to Stroustrup in the C++ Programming Language:
Which style you use depends on circumstances and taste. I usually prefer to use struct for classes that have all data public. I think of such classes as "not quite proper types, just data structures."
Functionally, there is no difference other than the public / private
Members of a class are private by default and members of struct are public by default.
For example program 1 fails in compilation and program 2 works fine.
// Program 1
#include <stdio.h>
class Test {
int x; // x is private
};
int main()
{
Test t;
t.x = 20; // compiler error because x is private
getchar();
return 0;
}
// Program 2
#include <stdio.h>
struct Test {
int x; // x is public
};
int main()
{
Test t;
t.x = 20; // works fine because x is public
getchar();
return 0;
}
When deriving a struct from a class/struct, default access-specifier for a base class/struct is public. And when deriving a class, default access specifier is private.
For example program 3 fails in compilation and program 4 works fine.
// Program 3
#include <stdio.h>
class Base {
public:
int x;
};
class Derived : Base { }; // is equivalent to class Derived : private Base {}
int main()
{
Derived d;
d.x = 20; // compiler error because inheritance is private
getchar();
return 0;
}
// Program 4
#include <stdio.h>
class Base {
public:
int x;
};
struct Derived : Base { }; // is equivalent to struct Derived : public Base {}
int main()
{
Derived d;
d.x = 20; // works fine because inheritance is public
getchar();
return 0;
}
STRUCT is a type of Abstract Data Type that divides up a given chunk of memory according to the structure specification. Structs are particularly useful in file serialization/deserialization as the structure can often be written to the file verbatim. (i.e. Obtain a pointer to the struct, use the SIZE macro to compute the number of bytes to copy, then move the data in or out of the struct.)
Classes are a different type of abstract data type that attempt to ensure information hiding. Internally, there can be a variety of machinations, methods, temp variables, state variables. etc. that are all used to present a consistent API to any code which wishes to use the class.
In effect, structs are about data, classes are about code.
However, you do need to understand that these are merely abstractions. It's perfectly possible to create structs that look a lot like classes and classes that look a lot like structs. In fact, the earliest C++ compilers were merely pre-compilers that translates C++ code to C. Thus these abstractions are a benefit to logical thinking, not necessarily an asset to the computer itself.
Beyond the fact that each is a different type of abstraction, Classes provide solutions to the C code naming puzzle. Since you can't have more than one function exposed with the same name, developers used to follow a pattern of _(). e.g. mathlibextreme_max(). By grouping APIs into classes, similar functions (here we call them "methods") can be grouped together and protected from the naming of methods in other classes. This allows the programmer to organize his code better and increase code reuse. In theory, at least.
The only other difference is the default inheritance of classes and structs, which, unsurprisingly, is private and public respectively.
The difference between class and struct is a difference between keywords, not between data types. This two
struct foo : foo_base { int x;};
class bar : bar_base { int x; };
both define a class type. The difference of the keywords in this context is the different default access:
foo::x is public and foo_base is inherited publicly
bar::x is private and bar_base is inherited privately
The members of a structure are public by default, the members of class are private by default.
Default inheritance for Structure from another structure or class is public.Default inheritance for class from another structure or class is private.
class A{
public:
int i;
};
class A2:A{
};
struct A3:A{
};
struct abc{
int i;
};
struct abc2:abc{
};
class abc3:abc{
};
int _tmain(int argc, _TCHAR* argv[])
{
abc2 objabc;
objabc.i = 10;
A3 ob;
ob.i = 10;
//A2 obja; //privately inherited
//obja.i = 10;
//abc3 obss;
//obss.i = 10;
}
This is on VS2005.
Not in the specification, no. The main difference is in programmer expectations when they read your code in 2 years. structs are often assumed to be POD. Structs are also used in template metaprogramming when you're defining a type for purposes other than defining objects.
One other thing to note, if you updated a legacy app that had structs to use classes you might run into the following issue:
Old code has structs, code was cleaned up and these changed to classes.
A virtual function or two was then added to the new updated class.
When virtual functions are in classes then internally the compiler will add extra pointer to the class data to point to the functions.
How this would break old legacy code is if in the old code somewhere the struct was cleared using memfill to clear it all to zeros, this would stomp the extra pointer data as well.
Another main difference is when it comes to Templates. As far as I know, you may use a class when you define a template but NOT a struct.
template<class T> // OK
template<struct T> // ERROR, struct not allowed here
Member of a class defined with the keyword class are private by default. Members of a class defined with the keywords struct (or union) are public by default.
In absence of an access-specifier for a base class, public is assumed when the derived class is declared struct and private is assumed when the class is declared class.
You can use template<class T> but not template<struct T>.
Note also that the C++ standard allows you to forward-declare a type as a struct, and then use class when declaring the type and vice-versa. Also, std::is_class<Y>::value is true for Y being a struct and a class, but is false for an enum class.
Here is a good explanation: http://carcino.gen.nz/tech/cpp/struct_vs_class.php
So, one more time: in C++, a struct is identical to a class except that the members of a struct have public visibility by default, but the members of a class have private visibility by default.
It's just a convention. Structs can be created to hold simple data but later evolve time with the addition of member functions and constructors. On the other hand it's unusual to see anything other than public: access in a struct.
ISO IEC 14882-2003
9 Classes
§3
A structure is a class defined with
the class-key struct; its members
and base classes (clause 10) are
public by default (clause 11).
The other answers have mentioned the private/public defaults, (but note that a struct is a class is a struct; they are not two different items, just two ways of defining the same item).
What might be interesting to note (particularly since the asker is likely to be using MSVC++ since he mentions "unmanaged" C++) is that Visual C++ complains under certain circumstances if a class is declared with class and then defined with struct (or possibly the other way round), although the standard says that is perfectly legal.
. In classes all the members by default are private but in structure
members are public by default.
There is no term like constructor and destructor for structs, but for class compiler creates default if you don't provide.
Sizeof empty structure is 0 Bytes wer as Sizeof empty class is 1 Byte The struct default access type is public. A struct should
typically be used for grouping data.
The class default access type is private, and the default mode for
inheritance is private. A class should be used for grouping data and
methods that operate on that data.
In short, the convention is to use struct when the purpose is to
group data, and use classes when we require data abstraction and,
perhaps inheritance.
In C++ structures and classes are passed by value, unless explicitly
de-referenced. In other languages classes and structures may have
distinct semantics - ie. objects (instances of classes) may be passed
by reference and structures may be passed by value. Note: There are
comments associated with this question. See the discussion page to
add to the conversation.
While implied by other answers, it's not explicitly mentioned - that structs are C compatible, depending on usage; classes are not.
This means if you're writing a header that you want to be C compatible then you've no option other than struct (which in the C world can't have functions; but can have function pointers).
There exists also unwritten rule that tells:
If data members of class have no association with itself, use struct.
If value of data member depends on another value of data member, use class.
f.e
class Time
{
int minutes;
int seconds;
}
struct Sizes
{
int length;
int width;
};
You might consider this for guidelines on when to go for struct or class, https://msdn.microsoft.com/en-us/library/ms229017%28v=vs.110%29.aspx .
√ CONSIDER defining a struct instead of a class if instances of the
type are small and commonly short-lived or are commonly embedded in
other objects.
X AVOID defining a struct unless the type has all of
the following characteristics:
It logically represents a single value,
similar to primitive types (int, double, etc.).
It has an instance
size under 16 bytes.
It is immutable.
It will not have to be boxed
frequently.
The difference between struct and class keywords in C++ is that, when there is no specific specifier on particular composite data type then by default struct or union is the public keywords that merely considers data hiding but class is the private keyword that considers the hiding of program codes or data. Always some programmers use struct for data and class for code sake. For more information contact other sources.
Out of all these factors,it can be concluded that concept Class is highly suitable to represent real world objects rather than "Structures".Largely because OOP concepts used in class are highly practical in explaining real world scenarios therefore easier to merge them to reality.For an example,default inheritance is public for structs but if we apply this rule for real world,it's ridiculous.But in a class default inheritance is private which is more realistic.
Anyways,what i need to justify is Class is a much broader,real world applicable concept whereas Structure is a primitive Concept with poor internal organization(Eventhough struct follows OOP concepts,they have a poor meaning)
Class is only meaningful in the context of software engineering. In the context of data structures and algorithms, class and struct are not that different. There's no any rule restricted that class's member must be referenced.
When developing large project with tons of people without class, you may finally get complicated coupled code because everybody use whatever functions and data they want. class provides permission controls and inherents to enhance decoupling and reusing codes.
If you read some software engineering principles, you'll find most standards can not be implemented easily without class. for example:
http://en.wikipedia.org/wiki/SOLID_%28object-oriented_design%29
BTW, When a struct allocates a crunch of memory and includes several variables, value type variables indicates that values are embbeded in where struct is allocated. In contrast, reference type variable's values are external and reference by a pointer which is also embedded in where struct is allocated.
The main difference between structure and class keyword in oops is that, no public and private member declaration present in structure.and the data member and member function can be defined as public, private as well as protected.
The main difference between struct and class is that in struct you can only declare data variables of different data types while in class you can declare data variables,member functions and thus you can manipulate data variables through functions.
-> another handy thing that i find in class vs struct is that while implementing files in a program if you want to make some operations of a struct again and again on every new set of operations you need to make a separate function and you need to pass object of struct after reading it from the file so as to make some operations on it .
while in class if you make a function that does some operations on the data needed everytime..its easy you just have to read object from file and call the function..
But it depennds on the programmer which way he/she finds suitable...according to me i prefer class everytime just because it supports OOPs and thats the reason it is implemented in almost every languages and its the wonderful feature of all time programming ;-)
And yeah the most unforgotten difference i forgot to mention is that class supports data hiding and also supports operations that are performed on built in data types while struct doesnt !
I found an other difference. if you do not define a constructor in a class, the compiler will define one. but in a struct if you do not define a constructor, the compiler do not define a constructor too. so in some cases that we really do not need a constructor, struct is a better choice (performance tip).
and sorry for my bad English.
Classes are Reference types and Structures are Values types.
When I say Classes are reference types,
basically they will contain the address of an instance variables.
For example:
Class MyClass
{
Public Int DataMember; //By default, accessibility of class data members
//will be private. So I am making it as Public which
//can be accessed outside of the class.
}
In main method,
I can create an instance of this class using new operator that allocates memory for this class
and stores the base address of that into MyClass type variable(_myClassObject2).
Static Public void Main (string[] arg)
{
MyClass _myClassObject1 = new MyClass();
_myClassObject1.DataMember = 10;
MyClass _myClassObject2 = _myClassObject1;
_myClassObject2.DataMember=20;
}
In the above program,
MyClass _myClassObject2 = _myClassObject1;
instruction indicates that both variables of type MyClass
myClassObject1
myClassObject2
and will point to the same memory location.
It basically assigns the same memory location into another variable of same type.
So if any changes that we make in any one of the objects type MyClass will have an effect on another
since both are pointing to the same memory location.
"_myClassObject1.DataMember = 10;" at this line both the object’s data members will contain the value of 10.
"_myClassObject2.DataMember = 20;" at this line both the object’s data member will contains the value of 20.
Eventually, we are accessing datamembers of an object through pointers.
Unlike classes, structures are value types.
For example:
Structure MyStructure
{
Public Int DataMember; //By default, accessibility of Structure data
//members will be private. So I am making it as
//Public which can be accessed out side of the structure.
}
Static Public void Main (string[] arg)
{
MyStructure _myStructObject1 = new MyStructure();
_myStructObject1.DataMember = 10;
MyStructure _myStructObject2 = _myStructObject1;
_myStructObject2.DataMember = 20;
}
In the above program,
instantiating the object of MyStructure type using new operator and
storing address into _myStructObject variable of type MyStructure and
assigning value 10 to data member of the structure using "_myStructObject1.DataMember = 10".
In the next line,
I am declaring another variable _myStructObject2 of type MyStructure and assigning _myStructObject1 into that.
Here .NET C# compiler creates another copy of _myStructureObject1 object and
assigns that memory location into MyStructure variable _myStructObject2.
So whatever change we make on _myStructObject1 will never have an effect on another variable _myStructObject2 of type MyStructrue.
That’s why we are saying Structures are value types.
So the immediate Base class for class is Object and immediate Base class for Structure is ValueType which inherits from Object.
Classes will support an Inheritance whereas Structures won’t.
How are we saying that?
And what is the reason behind that?
The answer is Classes.
It can be abstract, sealed, static, and partial and can’t be Private, Protected and protected internal.
There are 3 basic difference between structure and class
1St- memory are reserved for structure in stack memory (which is near to programming language )whether for class in stack memory are reserved for only reffrence and actual memory are reserved in heap memory.
2Nd - By default structure treat as a public whether class treat as a private .
3Rd- can't re -use code in structure but in class we can re-use same code in many time called inhertence
This question was already asked in the context of C#/.Net.
Now I'd like to learn the differences between a struct and a class in C++. Please discuss the technical differences as well as reasons for choosing one or the other in OO design.
I'll start with an obvious difference:
If you don't specify public: or private:, members of a struct are public by default; members of a class are private by default.
I'm sure there are other differences to be found in the obscure corners of the C++ specification.
You forget the tricky 2nd difference between classes and structs.
Quoth the standard (§11.2.2 in C++98 through C++11):
In absence of an access-specifier
for a base class, public is assumed
when the derived class is declared
struct and private is assumed when the class is declared class.
And just for completeness' sake, the more widely known difference between class and struct is defined in (11.2):
Member of a class defined with the
keyword class are private by
default. Members of a class defined
with the keywords struct or union
are public by default.
Additional difference: the keyword class can be used to declare template parameters, while the struct keyword cannot be so used.
Quoting The C++ FAQ,
[7.8] What's the difference between
the keywords struct and class?
The members and base classes of a
struct are public by default, while in
class, they default to private. Note:
you should make your base classes
explicitly public, private, or
protected, rather than relying on the
defaults.
Struct and class are otherwise
functionally equivalent.
OK, enough of that squeaky clean
techno talk. Emotionally, most
developers make a strong distinction
between a class and a struct. A
struct simply feels like an open pile
of bits with very little in the way of
encapsulation or functionality. A
class feels like a living and
responsible member of society with
intelligent services, a strong
encapsulation barrier, and a well
defined interface. Since that's the
connotation most people already have,
you should probably use the struct
keyword if you have a class that has
very few methods and has public data
(such things do exist in well designed
systems!), but otherwise you should
probably use the class keyword.
It's worth remembering C++'s origins in, and compatibility with, C.
C has structs, it has no concept of encapsulation, so everything is public.
Being public by default is generally considered a bad idea when taking an object-oriented approach, so in making a form of C that is natively conducive to OOP (you can do OO in C, but it won't help you) which was the idea in C++ (originally "C With Classes"), it makes sense to make members private by default.
On the other hand, if Stroustrup had changed the semantics of struct so that its members were private by default, it would have broken compatibility (it is no longer as often true as the standards diverged, but all valid C programs were also valid C++ programs, which had a big effect on giving C++ a foothold).
So a new keyword, class was introduced to be exactly like a struct, but private by default.
If C++ had come from scratch, with no history, then it would probably have only one such keyword. It also probably wouldn't have made the impact it made.
In general, people will tend to use struct when they are doing something like how structs are used in C; public members, no constructor (as long as it isn't in a union, you can have constructors in structs, just like with classes, but people tend not to), no virtual methods, etc. Since languages are as much to communicate with people reading the code as to instruct machines (or else we'd stick with assembly and raw VM opcodes) it's a good idea to stick with that.
Class' members are private by default. Struct's members are public by default. Besides that there are no other differences. Also see this question.
According to Stroustrup in the C++ Programming Language:
Which style you use depends on circumstances and taste. I usually prefer to use struct for classes that have all data public. I think of such classes as "not quite proper types, just data structures."
Functionally, there is no difference other than the public / private
Members of a class are private by default and members of struct are public by default.
For example program 1 fails in compilation and program 2 works fine.
// Program 1
#include <stdio.h>
class Test {
int x; // x is private
};
int main()
{
Test t;
t.x = 20; // compiler error because x is private
getchar();
return 0;
}
// Program 2
#include <stdio.h>
struct Test {
int x; // x is public
};
int main()
{
Test t;
t.x = 20; // works fine because x is public
getchar();
return 0;
}
When deriving a struct from a class/struct, default access-specifier for a base class/struct is public. And when deriving a class, default access specifier is private.
For example program 3 fails in compilation and program 4 works fine.
// Program 3
#include <stdio.h>
class Base {
public:
int x;
};
class Derived : Base { }; // is equivalent to class Derived : private Base {}
int main()
{
Derived d;
d.x = 20; // compiler error because inheritance is private
getchar();
return 0;
}
// Program 4
#include <stdio.h>
class Base {
public:
int x;
};
struct Derived : Base { }; // is equivalent to struct Derived : public Base {}
int main()
{
Derived d;
d.x = 20; // works fine because inheritance is public
getchar();
return 0;
}
STRUCT is a type of Abstract Data Type that divides up a given chunk of memory according to the structure specification. Structs are particularly useful in file serialization/deserialization as the structure can often be written to the file verbatim. (i.e. Obtain a pointer to the struct, use the SIZE macro to compute the number of bytes to copy, then move the data in or out of the struct.)
Classes are a different type of abstract data type that attempt to ensure information hiding. Internally, there can be a variety of machinations, methods, temp variables, state variables. etc. that are all used to present a consistent API to any code which wishes to use the class.
In effect, structs are about data, classes are about code.
However, you do need to understand that these are merely abstractions. It's perfectly possible to create structs that look a lot like classes and classes that look a lot like structs. In fact, the earliest C++ compilers were merely pre-compilers that translates C++ code to C. Thus these abstractions are a benefit to logical thinking, not necessarily an asset to the computer itself.
Beyond the fact that each is a different type of abstraction, Classes provide solutions to the C code naming puzzle. Since you can't have more than one function exposed with the same name, developers used to follow a pattern of _(). e.g. mathlibextreme_max(). By grouping APIs into classes, similar functions (here we call them "methods") can be grouped together and protected from the naming of methods in other classes. This allows the programmer to organize his code better and increase code reuse. In theory, at least.
The only other difference is the default inheritance of classes and structs, which, unsurprisingly, is private and public respectively.
The difference between class and struct is a difference between keywords, not between data types. This two
struct foo : foo_base { int x;};
class bar : bar_base { int x; };
both define a class type. The difference of the keywords in this context is the different default access:
foo::x is public and foo_base is inherited publicly
bar::x is private and bar_base is inherited privately
The members of a structure are public by default, the members of class are private by default.
Default inheritance for Structure from another structure or class is public.Default inheritance for class from another structure or class is private.
class A{
public:
int i;
};
class A2:A{
};
struct A3:A{
};
struct abc{
int i;
};
struct abc2:abc{
};
class abc3:abc{
};
int _tmain(int argc, _TCHAR* argv[])
{
abc2 objabc;
objabc.i = 10;
A3 ob;
ob.i = 10;
//A2 obja; //privately inherited
//obja.i = 10;
//abc3 obss;
//obss.i = 10;
}
This is on VS2005.
Not in the specification, no. The main difference is in programmer expectations when they read your code in 2 years. structs are often assumed to be POD. Structs are also used in template metaprogramming when you're defining a type for purposes other than defining objects.
One other thing to note, if you updated a legacy app that had structs to use classes you might run into the following issue:
Old code has structs, code was cleaned up and these changed to classes.
A virtual function or two was then added to the new updated class.
When virtual functions are in classes then internally the compiler will add extra pointer to the class data to point to the functions.
How this would break old legacy code is if in the old code somewhere the struct was cleared using memfill to clear it all to zeros, this would stomp the extra pointer data as well.
Another main difference is when it comes to Templates. As far as I know, you may use a class when you define a template but NOT a struct.
template<class T> // OK
template<struct T> // ERROR, struct not allowed here
Member of a class defined with the keyword class are private by default. Members of a class defined with the keywords struct (or union) are public by default.
In absence of an access-specifier for a base class, public is assumed when the derived class is declared struct and private is assumed when the class is declared class.
You can use template<class T> but not template<struct T>.
Note also that the C++ standard allows you to forward-declare a type as a struct, and then use class when declaring the type and vice-versa. Also, std::is_class<Y>::value is true for Y being a struct and a class, but is false for an enum class.
Here is a good explanation: http://carcino.gen.nz/tech/cpp/struct_vs_class.php
So, one more time: in C++, a struct is identical to a class except that the members of a struct have public visibility by default, but the members of a class have private visibility by default.
It's just a convention. Structs can be created to hold simple data but later evolve time with the addition of member functions and constructors. On the other hand it's unusual to see anything other than public: access in a struct.
ISO IEC 14882-2003
9 Classes
§3
A structure is a class defined with
the class-key struct; its members
and base classes (clause 10) are
public by default (clause 11).
The other answers have mentioned the private/public defaults, (but note that a struct is a class is a struct; they are not two different items, just two ways of defining the same item).
What might be interesting to note (particularly since the asker is likely to be using MSVC++ since he mentions "unmanaged" C++) is that Visual C++ complains under certain circumstances if a class is declared with class and then defined with struct (or possibly the other way round), although the standard says that is perfectly legal.
. In classes all the members by default are private but in structure
members are public by default.
There is no term like constructor and destructor for structs, but for class compiler creates default if you don't provide.
Sizeof empty structure is 0 Bytes wer as Sizeof empty class is 1 Byte The struct default access type is public. A struct should
typically be used for grouping data.
The class default access type is private, and the default mode for
inheritance is private. A class should be used for grouping data and
methods that operate on that data.
In short, the convention is to use struct when the purpose is to
group data, and use classes when we require data abstraction and,
perhaps inheritance.
In C++ structures and classes are passed by value, unless explicitly
de-referenced. In other languages classes and structures may have
distinct semantics - ie. objects (instances of classes) may be passed
by reference and structures may be passed by value. Note: There are
comments associated with this question. See the discussion page to
add to the conversation.
While implied by other answers, it's not explicitly mentioned - that structs are C compatible, depending on usage; classes are not.
This means if you're writing a header that you want to be C compatible then you've no option other than struct (which in the C world can't have functions; but can have function pointers).
There exists also unwritten rule that tells:
If data members of class have no association with itself, use struct.
If value of data member depends on another value of data member, use class.
f.e
class Time
{
int minutes;
int seconds;
}
struct Sizes
{
int length;
int width;
};
You might consider this for guidelines on when to go for struct or class, https://msdn.microsoft.com/en-us/library/ms229017%28v=vs.110%29.aspx .
√ CONSIDER defining a struct instead of a class if instances of the
type are small and commonly short-lived or are commonly embedded in
other objects.
X AVOID defining a struct unless the type has all of
the following characteristics:
It logically represents a single value,
similar to primitive types (int, double, etc.).
It has an instance
size under 16 bytes.
It is immutable.
It will not have to be boxed
frequently.
The difference between struct and class keywords in C++ is that, when there is no specific specifier on particular composite data type then by default struct or union is the public keywords that merely considers data hiding but class is the private keyword that considers the hiding of program codes or data. Always some programmers use struct for data and class for code sake. For more information contact other sources.
Out of all these factors,it can be concluded that concept Class is highly suitable to represent real world objects rather than "Structures".Largely because OOP concepts used in class are highly practical in explaining real world scenarios therefore easier to merge them to reality.For an example,default inheritance is public for structs but if we apply this rule for real world,it's ridiculous.But in a class default inheritance is private which is more realistic.
Anyways,what i need to justify is Class is a much broader,real world applicable concept whereas Structure is a primitive Concept with poor internal organization(Eventhough struct follows OOP concepts,they have a poor meaning)
Class is only meaningful in the context of software engineering. In the context of data structures and algorithms, class and struct are not that different. There's no any rule restricted that class's member must be referenced.
When developing large project with tons of people without class, you may finally get complicated coupled code because everybody use whatever functions and data they want. class provides permission controls and inherents to enhance decoupling and reusing codes.
If you read some software engineering principles, you'll find most standards can not be implemented easily without class. for example:
http://en.wikipedia.org/wiki/SOLID_%28object-oriented_design%29
BTW, When a struct allocates a crunch of memory and includes several variables, value type variables indicates that values are embbeded in where struct is allocated. In contrast, reference type variable's values are external and reference by a pointer which is also embedded in where struct is allocated.
The main difference between structure and class keyword in oops is that, no public and private member declaration present in structure.and the data member and member function can be defined as public, private as well as protected.
The main difference between struct and class is that in struct you can only declare data variables of different data types while in class you can declare data variables,member functions and thus you can manipulate data variables through functions.
-> another handy thing that i find in class vs struct is that while implementing files in a program if you want to make some operations of a struct again and again on every new set of operations you need to make a separate function and you need to pass object of struct after reading it from the file so as to make some operations on it .
while in class if you make a function that does some operations on the data needed everytime..its easy you just have to read object from file and call the function..
But it depennds on the programmer which way he/she finds suitable...according to me i prefer class everytime just because it supports OOPs and thats the reason it is implemented in almost every languages and its the wonderful feature of all time programming ;-)
And yeah the most unforgotten difference i forgot to mention is that class supports data hiding and also supports operations that are performed on built in data types while struct doesnt !
I found an other difference. if you do not define a constructor in a class, the compiler will define one. but in a struct if you do not define a constructor, the compiler do not define a constructor too. so in some cases that we really do not need a constructor, struct is a better choice (performance tip).
and sorry for my bad English.
Classes are Reference types and Structures are Values types.
When I say Classes are reference types,
basically they will contain the address of an instance variables.
For example:
Class MyClass
{
Public Int DataMember; //By default, accessibility of class data members
//will be private. So I am making it as Public which
//can be accessed outside of the class.
}
In main method,
I can create an instance of this class using new operator that allocates memory for this class
and stores the base address of that into MyClass type variable(_myClassObject2).
Static Public void Main (string[] arg)
{
MyClass _myClassObject1 = new MyClass();
_myClassObject1.DataMember = 10;
MyClass _myClassObject2 = _myClassObject1;
_myClassObject2.DataMember=20;
}
In the above program,
MyClass _myClassObject2 = _myClassObject1;
instruction indicates that both variables of type MyClass
myClassObject1
myClassObject2
and will point to the same memory location.
It basically assigns the same memory location into another variable of same type.
So if any changes that we make in any one of the objects type MyClass will have an effect on another
since both are pointing to the same memory location.
"_myClassObject1.DataMember = 10;" at this line both the object’s data members will contain the value of 10.
"_myClassObject2.DataMember = 20;" at this line both the object’s data member will contains the value of 20.
Eventually, we are accessing datamembers of an object through pointers.
Unlike classes, structures are value types.
For example:
Structure MyStructure
{
Public Int DataMember; //By default, accessibility of Structure data
//members will be private. So I am making it as
//Public which can be accessed out side of the structure.
}
Static Public void Main (string[] arg)
{
MyStructure _myStructObject1 = new MyStructure();
_myStructObject1.DataMember = 10;
MyStructure _myStructObject2 = _myStructObject1;
_myStructObject2.DataMember = 20;
}
In the above program,
instantiating the object of MyStructure type using new operator and
storing address into _myStructObject variable of type MyStructure and
assigning value 10 to data member of the structure using "_myStructObject1.DataMember = 10".
In the next line,
I am declaring another variable _myStructObject2 of type MyStructure and assigning _myStructObject1 into that.
Here .NET C# compiler creates another copy of _myStructureObject1 object and
assigns that memory location into MyStructure variable _myStructObject2.
So whatever change we make on _myStructObject1 will never have an effect on another variable _myStructObject2 of type MyStructrue.
That’s why we are saying Structures are value types.
So the immediate Base class for class is Object and immediate Base class for Structure is ValueType which inherits from Object.
Classes will support an Inheritance whereas Structures won’t.
How are we saying that?
And what is the reason behind that?
The answer is Classes.
It can be abstract, sealed, static, and partial and can’t be Private, Protected and protected internal.
There are 3 basic difference between structure and class
1St- memory are reserved for structure in stack memory (which is near to programming language )whether for class in stack memory are reserved for only reffrence and actual memory are reserved in heap memory.
2Nd - By default structure treat as a public whether class treat as a private .
3Rd- can't re -use code in structure but in class we can re-use same code in many time called inhertence
I want to define an abstract base class with a vector of struct variables, and a virtual function to be implemented by derived classes:
class TestFather {
private:
struct myStruct
{
// struct definition
};
vector<myStruct> myStructVect;
public:
virtual vector<myStruct> get_myStructVect() = 0;
};
but when I write the derived class:
#include "TestFather.h"
class TestSon : public TestFather{
private:
struct myStruct
{
// struct definition
};
vector<myStruct> myStructVect;
public:
vector<myStruct> get_myStructVect();
};
I get this error:
invalid covariant return type for ‘virtual std::vector<ProvaSon::myStruct, std::allocator<ProvaSon::myStruct> > ProvaSon::get_myStructVect()’
Am I doing something wrong or maybe I'm trying to do something that is forbidden by the language?
The two myStruct types are totally unrelated. This means that you're trying to override TestFather::get_myStructVect() and have it return a completely different type. This is not allowed.
You don't have to redefine the struct in TestSon, and you also can't do this. The caller of fatherptr->get_myStructVect statically gets a vector<TestFather::myStruct> back, so the compiler forbids you to override the base class function like that, because the dynamically returned object would potentially be incompatible with vector<TestFather::myStruct> (who knows what you put into TestSon::myStruct and how vector differs in behavior from the base class vector?).
As for the allowed difference, C++ only allows the derived class return type to be a derived class of the base class return type, and only when the return types are pointers or references.
It's forbidden. Because you've redefined myStruct in your derived class, vector<myStruct> is a different type in the derived class than it is in the base class. They are two different myStructs.
You can only change the return type of that virtual function to something inherited from the return type declared in the base class. But vector<TestSon::myStruct> does not inherit from vector<TestFather::myStruct>
It says vector<myStruct> but since you changed myStruct in the child class it's actually two distinct types so each of the two functions thinks its returning a different type. This is only allowed for covariant types where the type is related to the actual type of the class containing the function.
Note that you probably shouldn't be returning a class attribute vector by value here anyway.
I can't tell what you really are intending to do, but the nested structures really shouldn't have the same name if they're two different things (and if they're the same, don't redefine it). My first gut reaction is that maybe the parent-child relationship isn't appropriate here. Have you considered other options? If you really need to return a different type in the child and the parent doesn't know about that, then you can't use a virtual interface to do this. You should just give the functions different names so you know what the return type should be.
With more details about your goals a better answer could be provided.
The duplicate private structure is a bit odd in your example. The below compiles fine, for instance:
class TestFather {
protected:
struct myStruct
{
// struct definition
};
vector<myStruct> myStructVect;
public:
virtual vector<myStruct> get_myStructVect() = 0;
};
class TestSon : public TestFather{
public:
vector<myStruct> get_myStructVect();
};
int main(int argc, char**argv)
{
TestSon testSon;
}
Note the replacement of private with protected, allowing derived classes access to the parent structure definition and myStructVect storage.
I was just going through some codes of C++.
Where in I came across the concept of reinterpret_cast operator.
EDIT 1 :
I know that accessing private members of a class is not recommended.
But in some situations we ought to go ahead and access them.
I have just put forth this question to get my concepts clear.
In the example that I referred,the private member of the Class is accessed by simply creating a structure with the same variables and then later on modified by implementing
reinterpret_cast operator.
I have understood the usage of reinterpret_cast operator,as in I know what it does,but I fail to understand how a structure could be used to modify the values of a private Class member.
Following is the source code which I referred:
Class:
class Student
{
public:
explicit Student(float percent) // Cannot be used for conversion
{
static int nid;
id = ++nid;
score = percent;
}
int Id() const
{
return id;
}
float GetScore() const
{
return score;
}
void SetScore(float value)
{
score = value;
}
virtual ~Student(){}
private:
int id;
float score;
};
Structure used to access and modify private class members:
struct _Student
{
void* vptr;
int id;
float score;
};
_Student* bs3 = reinterpret_cast<_Student*>(bs2);
bs3->id = 5;
Thank you.Please correct me if I'm wrong/I couldn't put forth my question in an appropriate manner.
$5.2.10/2 - "An expression of
integral, enumeration, pointer, or
pointer-to-member type can be
explicitly converted to its own type;
such a cast yields the value of its operand."
This means that pointers 'bs2' and 'bs3' are pointing to the same location
$9.2/16 - "Two standard-layout struct
(Clause 9) types are layout-compatible
if they have the same number of
non-static data members and
corresponding non-static data members
(in declaration order) have
layout-compatible types (3.9)."
This means that your class and struct are layout compatible.
$9/6-
A standard-layout class is a class
that:
— has no non-static data members
of type non-standard-layout class (or
array of such types) or reference,
— has no virtual functions (10.3) and no
virtual base classes (10.1),
— has the same access control (Clause 11) for
all non-static data members,
— has no non-standard-layout base classes,
— either has no non-static data members
in the most-derived class and at most
one base class with non-static data
members, or has no base classes with
non-static data members, and
— has no base classes of the same type as the
first non-static data member.108
Since your class has a virtual destructor, your class and struct are not standard layout classes.
However you have added a 'void *' data member to possibly take care of the 'vptr' (thereby possibly mimicking layout compatibility based on your particular compiler implementation)
In this case reinterpret_cast is used to interpret the class pointer (bs2) as a struct pointer (bs3). By default struct members are public. Since the return value of reinterpret cast points to the same memory (refer quote above) where class members are located, you can modify the struct members (which are the same as the original class members).
This is cheating. This is highly discouraged.! This is most likely going to lead to undefined behavior
But in some situations we ought to go ahead and access them.
And what, pray, are these situations?
Other than design errors, I can’t see any. Accessing private members is a no-go. If you need the access, then provide it by legal means, i.e. either make the members more accessible or use friend modifiers to access them in a controlled way.
Violating the C++ type checking system equals game over: you cheat the compiler, don’t expect it to work with you. With this kind of undefined behaviour (i.e. not just platform dependent but forbidden for good reasons) you’re just inviting trouble in the form of very hard to track bugs.
tl;dr: Don’t. Ever.
Caveat: There is one exception: you have a library that you cannot access/modify the source code of, and you have no way of influencing its interface design. And additionally you can be sure (how?) that it won’t ever change. In this case the only solution may be to hack the library with such tricks.
I think you should perhaps change the context of your question somewhat.
If you realize you need to access a private variable in your class then
you are facing a design problem that needs to be resolved instead of
hacked around using an unsafe type conversion. Even if it is just
hypothetical and for the sake of asking about reinterpret_cast here.
As for a use case of reinterpret_cast that makes sense I'd say inside a hash function:
unsigned short Hash( void *p )
{
unsigned int val = reinterpret_cast<unsigned int>( p );
return ( unsigned short )( val ^ (val >> 16));
}
Some links with useful info:
When should static_cast, dynamic_cast, const_cast and reinterpret_cast be used?
http://advancedcppwithexamples.blogspot.com/2010/02/reinterpretcast-in-c.html
http://www.linuxtopia.org/online_books/programming_books/thinking_in_c++/Chapter03_054.html
But in some situations we ought to go ahead and access them.
If you have to access them in any situation, change its access specification.
Or better, make a public method that would accept a token(or some special permissions - to validate the caller), and return the requested value.
What you've got there is a horrible hack around encapsulation. If you really want to access private variables then you should be using the "friend" keyword. The reason the reinterpret_cast works is because you're interpretting the bytes of class Student as the struct _Student - which has it's variables declared as public by default. There are all manner of bad ways to access the private data, here's another one I can think of:
int* bs3 = reinterpret_cast<int*>(bs2);
++bs3;
*bs3 = 5;
Just don't do it would be my advice.