this code is memory overflow or not?

[blackrosezy]

#include

char *code;

void main()

{

char buf[8] = "book";

strcpy(code, buf);

}

[mlimber]

bl*********@gmail.com wrote:

#include

char *code;

void main()

{

char buf[8] = "book";

strcpy(code, buf);

}

See FAQ 7.1 in comp.lang.c:

http://www.faqs.org/faqs/C-faq/faq/index.html

Cheers! --M

[Marcus Kwok]

bl*********@gmail.com wrote:

#include
It seems your newsreader ate your include statement. I will assume it
is <string.h> (or even <cstring> with appropriate using declarations).
char *code;
You never initialize nor allocate any memory for code.
void main()
int main()
main() ALWAYS returns an int in conforming code.
{

char buf[8] = "book";

strcpy(code, buf);
You never initialized code, so it is pointing to garbage.
}

Here is a working example, though prefer std::string to raw char*'s.
#include <cstring>

char* code;

int main()
{
char buf[] = "book";
code = new char[std::strlen(buf) + 1];
std::strcpy(code, buf);
delete[] code;
}

--
Marcus Kwok

[Jeffrey Baker]

"Marcus Kwok" <ri******@gehennom.net.invalid> wrote in message
news:dv**********@news-int2.gatech.edu...

bl*********@gmail.com wrote:

#include

It seems your newsreader ate your include statement. I will assume it
is <string.h> (or even <cstring> with appropriate using declarations).

char *code;

You never initialize nor allocate any memory for code.

void main()

int main()
main() ALWAYS returns an int in conforming code.

{

char buf[8] = "book";

strcpy(code, buf);

You never initialized code, so it is pointing to garbage.

}

Here is a working example, though prefer std::string to raw char*'s.
#include <cstring>

char* code;

int main()
{
char buf[] = "book";
code = new char[std::strlen(buf) + 1];
std::strcpy(code, buf);
delete[] code;
}

--
Marcus Kwok

Another way that is simpler is:

#include<iostream>

using std::cout;

using std::endl;

#include <cstring>

int main()

{

char* code;

char buf[] = "book";

code = buf;

cout << code << endl;
return 0;

}

Regards,

JB

[Marcus Kwok]

> "Marcus Kwok" <ri******@gehennom.net.invalid> wrote in message

#include <cstring>

char* code;

int main()
{
char buf[] = "book";
code = new char[std::strlen(buf) + 1];
std::strcpy(code, buf);
delete[] code;
}

Jeffrey Baker <tb******@earthlink.net> wrote: Another way that is simpler is:

#include<iostream>

using std::cout;

using std::endl;

#include <cstring>

int main()

{

char* code;

char buf[] = "book";

code = buf;

cout << code << endl;
return 0;

}

Yes, but then if you change an element of code, it also changes the
corresponding element of buf. In my version, code and buf are distinct
entities (that happen to have the same content), so if you change one,
the other is unaffected.

--
Marcus Kwok

[Jeffrey Baker]

"Marcus Kwok" <ri******@gehennom.net.invalid> wrote in message
news:dv**********@news-int.gatech.edu...

"Marcus Kwok" <ri******@gehennom.net.invalid> wrote in message

#include <cstring>

char* code;

int main()
{
char buf[] = "book";
code = new char[std::strlen(buf) + 1];
std::strcpy(code, buf);
delete[] code;
}

Jeffrey Baker <tb******@earthlink.net> wrote:

Another way that is simpler is:

#include<iostream>

using std::cout;

using std::endl;

#include <cstring>

int main()

{

char* code;

char buf[] = "book";

code = buf;

cout << code << endl;
return 0;

}

Yes, but then if you change an element of code, it also changes the
corresponding element of buf. In my version, code and buf are distinct
entities (that happen to have the same content), so if you change one,
the other is unaffected.

--
Marcus Kwok

I agree the new operator is good to use. I see a similarity between both
ways. In the "new" you delete the pointer so it no longer exists. In the
other eg. code = buf; , code no longer points to buf like "new" no longer
points to code. In my example code stays pointed to the object till code is
reassigned. That is like reasigning code with new after delete[] code; is
used. code is reassigned.

In both cases there needs to be a number of pointers in my example and with
new it seems to be the same to keep the data otherwise it is destroyed.

Regards,
JB

[Marcus Kwok]

> news:dv**********@news-int.gatech.edu...

"Marcus Kwok" <ri******@gehennom.net.invalid> wrote in message
char* code;

char buf[] = "book";
code = new char[std::strlen(buf) + 1];
std::strcpy(code, buf);
Jeffrey Baker <tb******@earthlink.net> wrote:

char* code;
char buf[] = "book";
code = buf;

"Marcus Kwok" <ri******@gehennom.net.invalid> wrote in message

Yes, but then if you change an element of code, it also changes the
corresponding element of buf. In my version, code and buf are distinct
entities (that happen to have the same content), so if you change one,
the other is unaffected.

Jeffrey Baker <tb******@earthlink.net> wrote: I agree the new operator is good to use. I see a similarity between both
ways. In the "new" you delete the pointer so it no longer exists. In the
other eg. code = buf; , code no longer points to buf like "new" no longer
points to code. In my example code stays pointed to the object till code is
reassigned. That is like reasigning code with new after delete[] code; is
used. code is reassigned.

In both cases there needs to be a number of pointers in my example and with
new it seems to be the same to keep the data otherwise it is destroyed.

I'm not quite sure what you're getting at here, but here is a program
that demonstrates what I am talking about:
#include <iostream>
#include <cstring>

int main()
{
std::cout << "My way:\n";
char* code;
char buf[] = "book";
code = new char[std::strlen(buf) + 1];
std::strcpy(code, buf);
std::cout << "code: " << code << ", buf: " << buf << '\n';
code[0] = 'n';
std::cout << "code: " << code << ", buf: " << buf << '\n';
delete[] code;
std::cout << "\nYour way:\n";
code = buf;
std::cout << "code: " << code << ", buf: " << buf << '\n';
code[0] = 'n';
std::cout << "code: " << code << ", buf: " << buf << '\n';
}

Output:
My way:
code: book, buf: book
code: nook, buf: book

Your way:
code: book, buf: book
code: nook, buf: nook

--
Marcus Kwok

[Jeffrey Baker]

"Marcus Kwok" <ri******@gehennom.net.invalid> wrote in message
news:dv**********@news-int.gatech.edu...

news:dv**********@news-int.gatech.edu...

"Marcus Kwok" <ri******@gehennom.net.invalid> wrote in message
> char* code;
>
> char buf[] = "book";
> code = new char[std::strlen(buf) + 1];
> std::strcpy(code, buf);

Jeffrey Baker <tb******@earthlink.net> wrote:
char* code;
char buf[] = "book";
code = buf;

"Marcus Kwok" <ri******@gehennom.net.invalid> wrote in message

Yes, but then if you change an element of code, it also changes the
corresponding element of buf. In my version, code and buf are distinct
entities (that happen to have the same content), so if you change one,
the other is unaffected.

Jeffrey Baker <tb******@earthlink.net> wrote:

I agree the new operator is good to use. I see a similarity between both
ways. In the "new" you delete the pointer so it no longer exists. In the
other eg. code = buf; , code no longer points to buf like "new" no longer
points to code. In my example code stays pointed to the object till code
is
reassigned. That is like reasigning code with new after delete[] code; is
used. code is reassigned.

In both cases there needs to be a number of pointers in my example and
with
new it seems to be the same to keep the data otherwise it is destroyed.

I'm not quite sure what you're getting at here, but here is a program
that demonstrates what I am talking about:
#include <iostream>
#include <cstring>

int main()
{
std::cout << "My way:\n";
char* code;
char buf[] = "book";
code = new char[std::strlen(buf) + 1];
std::strcpy(code, buf);
std::cout << "code: " << code << ", buf: " << buf << '\n';
code[0] = 'n';
std::cout << "code: " << code << ", buf: " << buf << '\n';
delete[] code;
std::cout << "\nYour way:\n";
code = buf;
std::cout << "code: " << code << ", buf: " << buf << '\n';
code[0] = 'n';
std::cout << "code: " << code << ", buf: " << buf << '\n';
}

Output:
My way:
code: book, buf: book
code: nook, buf: book

Your way:
code: book, buf: book
code: nook, buf: nook

--
Marcus Kwok

Thanks,

There is definitely more stability with the new operator.

Regards,
JB