[r.stiltskin]

Thanks for finding that. At least we can learn something from this otherwise pointless argument.

[ishkabible]

To follow up...

I was trying to think of a reason for that clause(other than not breaking legacy code) and I believe it's an optimization that allows using things like memcpy, memset, and memmove with iterators of containers that have this clause(one of the reasons std::vector is so fast). The idea is that there would be class template called something like 'contiguous_iter', containers like std::string and std::vector would use it, and the STL algorithms can use specializations, overloads or SFINE(not sure which would be used, maybe a combo) to select the fastest algorithm. I know VC++'s STL does this for std::vector; I bet it does the same thing with std::string sense they could easily have the same iterator implementation.

This post has been edited by ishkabible: 05 March 2012 - 08:44 PM

[Ricky65]

It's worth noting that if std::string wasn't required to be contiguous then the "data" and "c_str" member functions wouldn't be possible.

[vividexstance]

Ricky65, on 06 March 2012 - 06:06 PM, said:

It's worth noting that if std::string wasn't required to be contiguous then the "data" and "c_str" member functions wouldn't be possible.

In my opinion this statement is false. Bjarne Stroustrup says in his book "The C++ Programming Language: Special Edition" on page 589 that:

Quote

The data() function writes the characters of the string into an array and returns a pointer to that array. The array is owned by the string, and the user should not try to delete it. The user also cannot rely on its value after a subsequent call on a non-const function on the string. The c_str() function is like data(), except that it adds a 0(zero) at the end as a C-string-style terminator.

Maybe I'm interpreting it wrong, but hypothetically speaking if the string was implemented as lets say a linked list, it would still be possible to construct an array from that linked list and return a pointer to the first element of that array.

This post has been edited by vividexstance: 07 March 2012 - 10:49 AM

[ishkabible]

I interpret that the same way but I can't figure out how you would do it. if you create a reference for deleting the newly allocate pointer later then c_str can't be constant.

[vividexstance]

There are ways of making things const and not const, and even const member functions that actually might change something. Also, I think one could use statically allocated storage for the array just using the size of the linked-list or whatever data structure being used.

[r.stiltskin]

Isn't this horse dead yet?

OK, since I guess I was the perpetrator of this silly idea ...

I don't think we would want to have a linked list and a "permanent" array since linked list was intended to avoid an array in the first place. To satisfy c_str() we need a const array, but it only needs to be const until the next non-const method is called. So how about a dynamically allocated array that's initialized when c_str() is called (only if it isn't already non-null, as would be the case if c_str() is called multiple times with no intervening non-const method calls), and deleted by calling a private "destroyer" method whenever any non-const method is called.

This post has been edited by r.stiltskin: 08 March 2012 - 02:09 PM

[Ricky65]

vividexstance, on 07 March 2012 - 10:48 AM, said:

Ricky65, on 06 March 2012 - 06:06 PM, said:

It's worth noting that if std::string wasn't required to be contiguous then the "data" and "c_str" member functions wouldn't be possible.

In my opinion this statement is false. Bjarne Stroustrup says in his book "The C++ Programming Language: Special Edition" on page 589 that:

Quote

The data() function writes the characters of the string into an array and returns a pointer to that array. The array is owned by the string, and the user should not try to delete it. The user also cannot rely on its value after a subsequent call on a non-const function on the string. The c_str() function is like data(), except that it adds a 0(zero) at the end as a C-string-style terminator.

Maybe I'm interpreting it wrong, but hypothetically speaking if the string was implemented as lets say a linked list, it would still be possible to construct an array from that linked list and return a pointer to the first element of that array.

Sure, we could have a member function of a string class implemented with a linked list that returns a pointer to the first element in the relevant array.

However, the data() and c_str() member functions are usually passed to C functions which expect a contiguous built-in C array. This is the reason why only the contiguous collections, std::vector, std::array and std::string have the data() member function.

I would also like to add that since C++11, data() and c_str() perform the same function. data(), like c_str(), now appends a terminating null character.

[Kiakime]

Are vectors forbidden? 8) If not, this works.

Spoiler

#include <iostream>
#include <vector>
#include <string>

using namespace std;

int main() {
	string getInput;

	cout << "Please enter the string to be reversed." << endl;
	cin >> getInput;
	int i = getInput.length();

	vector<char> toReverse(getInput.begin(), getInput.end());

	do{
		cout << toReverse[i-1];
		i = i-1;
	} while (i != 0);

	return 0;
}

[vividexstance]

You could do without that do-while loop at the end:

Spoiler

#include <algorithm>
#include <iostream>
#include <iterator>
#include <vector>
#include <string>
using namespace std;

int main() {
	string getInput;
	cout << "Please enter the string to be reversed." << endl;
	cin >> getInput;
	int i = getInput.length();
	vector<char> toReverse(getInput.rbegin(), getInput.rend());
	cout << getInput << " reversed: ";
	copy(toReverse.begin(), toReverse.end(),
		ostream_iterator<char>(cout, ""));
	cout << endl;
	return 0;
}

This post has been edited by vividexstance: 18 March 2012 - 08:24 AM

[jjl]

You can pack your characters into a unsigned integer and pop them out as if they were a stack, this will print them in reverse.

Of course this only works for a 4-char string, but it was still fun

#include <iostream>

/* 4 character stack */
class char_pack {
	unsigned int data;
public:
	char_pack() 
		: data(0) {
	}

	void push(char c) {
		data = (data << 8) | c;
	}

	char pop() {
		char c = data & 0xFF;
		data = data >> 8;
		return c;
	}

	void print() {
		char c;
		if((c = pop()) != 0) {
			std::cout<<c;
			print();
		}
	}
};

int main() {

	char_pack str;
	str.push('t'); str.push('e'); str.push('s'); str.push('t');
	str.print(); //prints stack, which is the reversed string

	std::cin.ignore();
	std::cin.get();

	return 0;
}

This post has been edited by jjl: 01 April 2012 - 02:26 PM

[ishkabible]

best solution yet, that truly does not require pointers!

[r.stiltskin]

jjl, on 29 March 2012 - 10:31 PM, said:

You can pack your characters into a unsigned integer and pop them out as if they were a stack, this will print them in reverse.

Of course this only works for a 4-char string, but it was still fun

Excellent!

[Donanza]

Here is my solution:

#include <iostream>

using namespace std;

int main()
{
    int j = 0;
    int i;
    cout << "Enter a word or a sentence: ";
    string word;
    getline(cin, word);
    for (i = word.size() - 1; i >= 0; i--)
    {
        cout << word[i];
    }
    cout << "\n\n";
    main();
}

But i need help with the palindrome. Anyone knows how to do it?

[jjl]

Quote

Here is my solution:

Your using a string on line #10