Передача по ссылке

s2.lef( s1, n )    // в строку s2 помещаются n самых левых
           // символов строки s1
s2.mid( s1, s, n ) // в строку s2 помещаются n символов из 
                   // строки, начиная с символа номер s
s2.right( s1, n )  // в строку s2 помещаются n самых правых
           // символов строки s1

// task8.1.cpp
// date: Thu 04 Jul 2019 08:36:36 PM EEST
// source: page 409 from Lafore handbook, part 9
#include <iostream>
#include <string.h> // for "str*" functions
using namespace std;
////////////////////
enum { SZ = 80 };
class String
{
protected:    
    char str [ SZ ];
public:
    String()
    { str[ 0 ] = '\x0'; }
    String( char s [] )
    { strcpy( str, s ); }
    void display() const
    { cout << str; }
    operator char*()
    { return str; }
};
////////////////////
class Pstring : public String
{
public:
    Pstring(): String()
    { }
        Pstring( const char st [] )
        {
            if( strlen(st) < SZ ){
               // String::String( st );
                strcpy( str, st );
            }
            else{
                for(size_t i = 0; i < SZ-2; i++ ){
                    str[i] = st[i];
                    str[ SZ-1 ] == '\0';
                }
            }
        }
};
//////////////////////
class Pstring2 : public Pstring
{
    private:
    public:
        Pstring2(): Pstring()
        { }
        Pstring2( const char st []): Pstring(st)
        { }
        char*  left( Pstring2 sourceString, size_t number)
        {
            size_t begin = strlen(str);
        // check if size of copying string correspond to 
        // free place in old string
            if( SZ - 2 - begin > number){
        // then copy
                for(size_t i=0; i < number; begin++, i++){
                    str[begin] = sourceString.str[i];
                }
                str[begin+number] == '\0';
            }else{
                cout << "\n Your string "
                     << "does not tuck on "
                     << "initial string."
                     << "\nError!\n";
            }
            return str;
        }
        char* mid(Pstring2 obj, size_t beg, size_t number)
        {
            size_t begin = strlen(str);
            if(SZ - 1 - begin > number){
                for(size_t i = begin, j = beg; i < number; i++, j++){
                    str[i] = obj.str[j];
                }
                str[number] = '\0';
            }
            else{
                cout << "\n Your string "
                     << "does not tuck on "
                     << "initial string."
                     << "\nError!\n";
            }
            return str;
        }
        char* right(Pstring2 obj, size_t num)
        {
            size_t tmpSize = strlen(obj.str);
            size_t begin = strlen(str);
            size_t theEnd = begin+num;
            size_t start = tmpSize - 1 - num;
            if( SZ - 2 - begin > num){
                for(begin, start; begin < theEnd; begin++, start++){
                    str[begin] = obj.str[start];
                    tmpSize--;
                }
                str[begin+num] == '\0';
            }else{
                cout << "\n Your string "
                     << "does not tuck on "
                     << "initial string."
                     << "\nError!\n";
            }
 
            return str;
        }
        void clear()
        {
            for(size_t i = 0; i < SZ; i++){
                str[i] = '\0';
            }
        }
        size_t getStrSize()
        {
            return strlen(str);
        }
};
//////////////////////
int main()
{
    Pstring ps1("New constructorFrom inheritance class will copy to string SZ-1 characters onlyBut this is not a rule.");
    Pstring obj1("There is a very long string which must be "
"copied to the char array. And then suddenly arise a buffer overflow "
"error.");
    Pstring obj2("Kurz Sentenzen (de).");
     
    cout << endl;
    //////////////////
    Pstring2 obj3("This object of class Pstring2 demonstrate us a long string.");
    Pstring2 obj4("Not so long string.");
    Pstring2 obj6("Object6 very VEry VERy VERY long string could not tuck on initial string and you will have stack overflow if you will try to copy it there...");
 
    //////////////////
    cout << "\nObj3: ";
    obj3.display();
    cout << "\nObj3 size: " <<
    obj3.getStrSize();
    Pstring2 obj5;
    obj5 = obj3.left(obj6, 13);
    cout << "\nobj3.left(obj6, 30) results >> \n";
    obj5.display();
    cout << "\nClearing obj5...\n";
    obj5.clear();
    obj5.display();
    obj3.clear();
    obj3.display();
    cout << '\n';
    obj5 = obj3.mid(obj6, 18, 78);
    obj5.display();
    obj5.clear();
    cout << "\n test right...\n";
    cout << "\nClearing obj5...\n";
    obj5.clear();
    cout << "\nObj5: ";
    obj5.display();
    obj5 = obj4.right(obj6, 15);
    cout << "\nobj4.right(obj6, 15) results >> \n";
    obj5.display();
    cout << "\nClearing obj5...\n";
    obj5.clear();
    obj5 = obj4.right(obj6, 65);
    // test functions on the left side of "=" sign
    cout << "\ntest functions on the left side of \"=\" sign\n";
    obj5.clear();
/*    % g++ task8.1.cpp -o task8.1.exe 
        task8.1.cpp: In function ‘int main()’:
        task8.1.cpp:169:28: error: lvalue required as left operand of assignment
            obj5.right(obj6, 30) = obj4; // does not compile, want lvalue
    */
//    obj5.right(obj6, 30) = obj4; // does not compile, want lvalue
    obj5.display();
 
    return 0;
}

...
Pstring2& left(Pstring2 obj, int num)
{
        Pstring2 tmp;
        tmp.str = str;
        ...
        for(size_t i=0; i < number; begin++, i++){
                    tmp.str[begin] = sourceString.str[i];
        ...
        return tmp;
}

class Pstring
: public std::string
{
public:
 
    void left(const char *psz, size_t n)
    {
        const auto ln = strlen(psz);
        append(psz, psz + std::min(ln, n));
    }
........................................................
};

...
////////////////////
class Pstring : public String
{
public:
...

class Pstring
    : public std::string
{
public:
 
    Pstring & left(const char *psz, size_t n)
    {
        const auto ln = strlen(psz);
        append(psz, psz + std::min(ln, n));
        return *this;
    }
........................................................
};

int a = int(10); // int(10) - создает временный объект

int(10);

class SomeClass
{
private:
    int a;
    float b;
    double c;
public:
    SomeClass()
    {
        a = 0;
        b = 0;
        c = 0;
    }

...
SomeClass(): a=0, b=0, c=0
    { }

#include <iostream>
 
class A
{
public:
    A()
    { 
        buf[0] = '\0';
    }    
    A(const char * p)
    {
        strcpy(buf, p);
    }
    
    char buf[80];
};
 
class B : public A
{
public:
    B(const char * str)
    {
        if(strlen(str) < 80)
            A(str);
        else
            ; //......
    }
};
 
int main()
{
    B bb("hello world");
    
    std::cout << '[' << bb.buf << ']';
}

*this = String(s);

//----------------
Pstring::Pstring( char s[] ): String(s)
{ }

#include <iostream>
#include <string.h> // for "str*" functions
using namespace std;
////////////////////
class String
{
    protected:
        enum { SZ = 80 };
        char str[SZ];
    public:
        String()
        { str[0] = '\0'; }
        String( char s[] )
        { strcpy( str, s ); }
        void display() const
        { cout << str; }
        operator char* ()
        { return str; }
};
//////////////////////////////////
class Pstring : public String
{
    public: 
        Pstring( char s[] );
};
//------------------
Pstring::Pstring( char s[] )
{
    if(strlen(s) > SZ - 1)
    {
        int j = 0;
        for(j; j < SZ - 1; j++)
        {
            str[j] = s[j];
        }
        str[j] = '\0';
    }
    else
        String( s );
}
//------------
int main()
{
    Pstring obj1("some string here...");
    obj1.display();
 
    return 0;
}

String(char s[])
{
    char *p = str;
    for (size_t i = 1; i < SZ && *s; ++i)
        *(p++) = *(s++);
    *p = 0;
}