Const member function

[Wolfgang]

As I understand, a const member function is used by const object to
ensure that its instance isn't modified throughout its life. Am I
missing something..

#include <iostream>
using namespace std;

class A{

public:

A(char& str, size_t sz){
pch = new char [sz];
strncpy(pch, &str, sz);
}

char* print() const {
*pch = 'M';
return pch;
}
~A(){
delete pch;
}

private:
char* pch;
};

int main(){

const char str[] = "I a constant";

const A* obj = new A(*str, sizeof(str));
cout<<"obj->print() = "<<obj->print()<<end l;

return 0;
}

Wg

[James Kanze]

On Jun 15, 3:18 pm, Wolfgang <techreposit... @gmail.comwrote :

On Jun 15, 5:54 pm, "Victor Bazarov" <v.Abaza...@com Acast.netwrote:

[...]

~A(){
delete pch;

Your program has undefined behaviour here. You're supposed to use

delete[]

If my understanding is correct, delete[] is called when we want to
delete an array of objects - destructor needs to be called for each
object.

Won't be Ok if we use " delete pch " for deleting char array ?

It might, it might not. It's undefined behavior; an
implementation might choose to define it (although I don't know
of any which do), or it might happen to work by chance. But
it's forbidden by the language.

--
James Kanze (Gabi Software) email: ja*********@gma il.com
Conseils en informatique orientée objet/
Beratung in objektorientier ter Datenverarbeitu ng
9 place Sémard, 78210 St.-Cyr-l'École, France, [phone]

[James Kanze]

On Jun 15, 2:44 pm, Wolfgang <techreposit... @gmail.comwrote :

As I understand, a const member function is used by const object to
ensure that its instance isn't modified throughout its life. Am I
missing something..

Others have pointed out the technical aspects: the compiler only
understands what is called "bitwise" const. If you think about
it, how can it be otherwise? How can the compiler know whether
a pointer is part of the implementation of the object, and what
it points to is logically part of the object, or whether it is
there to allow navigation to another object, and of course, the
const-ness of the object which contains the pointer doesn't
affect the const-ness of the other object.

What hasn't been mentionned is the fact that you, as author of
the class, do know which pointers are part of your
implementation, and which ones are just for navigation. In a
very real sense, you define what const means for your object.
If parts of the basic bits are not part of your object's "value"
(as seen by client code), you can cast away const or use mutable
to modify them even in const functions. (The classical example
is a cached value, but I find that reference counters and mutexs
tend to occur more frequently.) And if something "pointed to"
is logically part of you object, you don't modify it from a
const function, even though the compiler allows it. This is
called "logical const", and I think that there is pretty much a
consensus today that this is how const in C++ should be used.

--
James Kanze (Gabi Software) email: ja*********@gma il.com
Conseils en informatique orientée objet/
Beratung in objektorientier ter Datenverarbeitu ng
9 place Sémard, 78210 St.-Cyr-l'École, France, [phone]

[Wolfgang]

On Jun 15, 7:52 pm, "Victor Bazarov" <v.Abaza...@com Acast.netwrote:

Wolfgang wrote:

[..]
Modifying the code a little bit here, esp changing the data member to
be public - so that I can access outside the class.

My comments inline with code relate only to style, not to functionality.

#include <iostream>
using namespace std;

class A{

public:

A(char& str, size_t sz){
pch = new char [sz];
strncpy(pch, &str, sz);
}

A(char const* str, size_t sz) : pch(new char[sz]) {
strncpy(pch, str, sz);
}

char* print() const {
*pch = 'M';
return pch;
}
~A(){
delete pch;
}

public:
char* pch;

};

int main(){

char str[] = "I a constant";

char const str[] = "I a constant";

const A* obj = new A(*str, sizeof(str));

const A* obj = new A(str, sizeof(str));

cout<<"obj->print() = "<<obj->print()<<end l;
cout<<"obj->pch = "<<obj->pch<<endl;
return 0;

}

I'm trying to print the member data which was initialised on the first
place, but modified on calling print().

I think you're missing something conceptual here. The data member
is _a pointer_, not the memory you allocated using 'new[]'. The
member, a pointer, does NOT change. You can print its value by
casting it to (void*). You will see that 'print' does not change
the value of the pointer and therefore does not change the value of
the constant object.

What you are changing is the contents of some memory which the 'pch'
pointer points to. That memory does NOT belong to your 'obj'. NOT.
Do you not understand that? There is no other ownership relationship
between 'obj' and the memory you allocate in 'A::A' than in your mind.

Sorry to ask again, just for better understanding

pch(new char [sz] ) or pch = new char [sz]; inside the above
constructor would allocate memory somewhere but it is not part of the
memory allocated for the object. ie.

Its not part of - " const A* obj = new A(str, sizeof(str)); "

and the member data of the class only has a pointer pointing to that
memory location ??. Am I rt ??

The compiler cannot prevent you from modifying that memory since it
is NOT part of the constant object 'obj'. Only _immediate_ parts of
the constant object cannot be modified, like 'pch' value itself. Try
assigning a different value to 'pch' (not to '*pch'), and you will
see what is meant by contant object.

V
--
Please remove capital 'A's when replying by e-mail
I do not respond to top-posted replies, please don't ask- Hide quoted text -

- Show quoted text -

[Victor Bazarov]

Wolfgang wrote:

[..] just for better understanding

pch(new char [sz] ) or pch = new char [sz]; inside the above
constructor would allocate memory somewhere but it is not part of the
memory allocated for the object. ie.

Its not part of - " const A* obj = new A(str, sizeof(str)); "

and the member data of the class only has a pointer pointing to that
memory location ??. Am I rt ??

S, U R rt.

V
--
Please remove capital 'A's when replying by e-mail
I do not respond to top-posted replies, please don't ask

[BobR]

Victor Bazarov wrote in message...

Wolfgang wrote:

[..] just for better understanding
pch(new char [sz] ) or pch = new char [sz]; inside the above
constructor would allocate memory somewhere but it is not part of the
memory allocated for the object. ie.

Its not part of - " const A* obj = new A(str, sizeof(str)); "

and the member data of the class only has a pointer pointing to that
memory location ??. Am I rt ??

S, U R rt.

Get off the 'texting' cell-phone and back on your computer. Drink two cups
of coffee. Type this 42 times:
"I will not cave in to kid stuff!"

There, feel better, or do we call Dr. Dobbs again?

--
Bob <GR
POVrookie