Thread: new operator

1. How come that changing the size of the memory allocated new char(256);
the size of the file wont change?
2. Why do we need to clear it with memset, when i write "world" to it and print it
hello is no longer there. Looks like it clears itself.

Code:

#include <iostream>
#include <windows.h>

using namespace std;
char *buffer = new char(256);

int main()
{
    strcpy(buffer, "hello");
    cout << buffer << "\n";
    strcpy(buffer, "world");
    cout << buffer << "\n";
    memset(buffer, 0, 256);
    cout << buffer << "\n";
    delete buffer;
    return 0;
}

I would suggest you use std::string instead of char.

Originally Posted by tabstop

3. That assumes that your buffer contains six characters in the first place, which I don't believe it does. Are you sure you don't mean "new char[256]" (and consequently "delete[] buffer") instead? Right now, you are getting one char, with the value 256.

Yeah except that a char probably wont hold 256 (0x100), so it'll actually hold 0 (0x00) instead.

std::string seconded.

Thanks, i go with string instead then.

So is it ok to replace this:

Code:

char *buffer = new char[256];

while(..)
{
memset(buffer, 0, length);

operation on buffer;
...
}
delete[] buffer;

with this:

Code:

string buffer ;

while(..)
{
operation on buffer;
...
...
}

Or do i need to clear std::string too everytime?

If you want an empty string for each iteration and the logic doesn't ensure that the string ends up being empty by the end of the loop, then naturally you should clear it. For that there is the clear() method.

Thank you Anon!

But if i should use a char* in a function i should go through all this transformation so i wonder if there is any good for using string?

Code:

string str; 
char buf[256];
strcpy(buf, str.c_str());

Its recv(), it takes a char*

Is it worth it to use string with it?

Code:

int recv(
  __in   SOCKET s,
  __out  char *buf,
  __in   int len,
  __in   int flags
);

Originally Posted by Ducky

Is it worth it to use string with it?

You may want to consider using a std::vector<char> instead, at least until it is guaranteed that the pointer returned by &str[0], where str is a std::string, points to the first character of a contiguous array of characters. (There is such a guarantee if str was a std::vector<char> instead.)

If you use std::vector<char>, don't forget to call resize() on the vector before you call recv().

Originally Posted by adeyblue

Didn't we go through this last time?

Yes, we did. I cannot recall the exact outcome of that conversation, but I did not go away convinced that Sutter is correct on this point. I believe it had something to do with ambiguity in the text of C++03. What I am convinced by is that there is no point debating as this will be fixed in the next version of the C++ standard, and for now one should play safe rather than sorry.

EDIT:
Ah yes, I remember now. The problem is that data() returns a const charT*, hence defining the non-const version of operator[] in terms of data() is illogical, but it is precisely that version of operator[] that is in question here.