Why didn't std::for_each + lambda work as expected? - c++

Question

It's an exercise from C++ Primer 5th Edition:
Exercise 14.7: Define an output operator for you String class you
wrote for the exercises in § 13.5 (p. 531).(Page 558)
The string.h I wrote for previous exercises:
/**
* #brief std::string like class without template
*
* design:
*
* [0][1][2][3][unconstructed chars][unallocated memory]
* ^ ^ ^
* elements first_free cap
*/
class String
{
friend std::ostream& operator <<(std::ostream& os, const String& s);
public:
//! default constructor
String();
//! constructor taking C-style string i.e. a char array terminated with'\0'.
explicit String(const char * const c);
//! copy constructor
explicit String(const String& s);
//! move constructor --07.Jan.2014
String(String&& s) noexcept;
//! operator =
String& operator = (const String& rhs);
//! move operator = --07.Jan.2014
String& operator = (String&& rhs) noexcept;
//! destructor
~String();
//! members
char* begin() const { return elements; }
char* end() const { return first_free; }
std::size_t size() const {return first_free - elements; }
std::size_t capacity() const {return cap - elements; }
private:
//! data members
char* elements;
char* first_free;
char* cap;
std::allocator<char> alloc;
//! utillities for big 3
void free();
};
std::ostream&
operator << (std::ostream& os, const String& s);
Part of the string.cpp:
//! constructor taking C-style string i.e. a char array terminated with'\0'.
String::String(const char * const c)
{
auto p = c;
char* newData = alloc.allocate(sizeof(p));
std::uninitialized_copy(p, (p + sizeof(p)), newData);
//! build the data structure
elements = newData;
cap = first_free = newData + sizeof(c);
}
std::ostream &operator <<(std::ostream &os, const String &s)
{
std::for_each(&s.elements, &s.first_free, [&](const char* p){
os << *p;
});
return os;
}
main.cpp:
#include "string.h"
#include <iostream>
int main()
{
String s("1234");
std::cout << s <<"\n";
return 0;
}
Output:
1
Press <RETURN> to close this window...
Why is the output like so? why not 1234?

Answer 1

Probably because elements points to an array of char, so each element is a char, not a char*.
You also need to drop the & in front of s.elements and s.first_free, because you are interested in the addresses the pointers point to, not the addresses of the pointers themselves.
So, this code would work:
std::for_each(s.elements, s.first_free, [&](char p){
os << p;
});
As mentioned by #TemplateRex in comments, it would be both cleaner and more idiomatic to use the begin() and end() member functions:
std::for_each(s.begin(), s.end(), [&](char p){ os << p; });

Answer 2

sizeof(pointer) where pointer is a char const* does not return the length of an array. You make this mistake multiple times. Use strlen instead. This is hidden because your string is 4 char long, and on a 32 bit system sizeof(ptr) is 4.
Next &first_free and similar in your for_each should be just first_free.
Next your lambda should take char not char*s. Then the output should be << p not << *p.
You should create both const and non-const begin and end. const returns char const *, while non const returns char* -- containers that logically own their underlying data should use const that way for iteration.
Next replace your for_eaxh to use begin() and end() like for_each( x.begin(), x.end(), ... -- no need to redo what begin and end do. In C++11 you can even use a ranged based for:
for(char c : s ) {
std::cout << c
}
instead of for_each.