user42225: How should I inherit from Stream, for creating a new class MySerial able to be initialized from a Stream0 instance?.
The error so far is: "cannot declare variable 'mySerial' to be of abstract type 'MySerial'".
If I make a class MySerial not inheriting, but adding a property Stream, everything works fine, except the new call mechanism for the resend() function, created to accept Stream instances.
EDIT: This is the edited code. Current error is: "expected unqualified-id before '=' token".
MySerial.h

class MySerial:public Stream{
    private:
        int param;
    public:
        MySerial(){}; // OK
        MySerial(Stream &Serial0){MySerial=&Serial0} // Here is the question
        // Stream Implementation
        int available(){return available();}
        int read(){return read();}
        int peek(){return peek();}
        size_t write(uint8_t c){return write(c);}
        using Print::write; 
};

MySerial.ino
#include <MySerial.h>
#include <SoftwareSerial.h>

SoftwareSerial swSerial(6,7);
MySerial mySerial(swSerial);

void setup(){}
void loop(){    
    if (mySerial.available()){
        c=mySerial.read();
        resend(mySerial,c);
    }
}
// This function should accept any Stream: SoftwareSerial, MySerial, Serial...
void resend(Stream &Stream0, char c){
    Stream0.write(c);
}


user37622: The Stream class has pure virtual methods which must be implemented in derived not abstract class.
The pure virtual method from base class Print is:
virtual size_t write(uint8_t) = 0;

The pure virtual methods from Stream are:
virtual int available() = 0;
virtual int read() = 0;
virtual int peek() = 0;

additionally add in your class the line
using Print::write; 

to pull in overloaded methods write(str) and write(buf, size) fromPrint
Here I have an example of a simple class derived from Stream.

EDIT: Most of your question seemed to focus on wrapping some Stream implementation. Now I see that you maybe want to enhance the SoftwareSerial class and add a new method in the inherited class. It is simple:
MySerial.h
#ifndef _MYSERIAL_H_
#define _MYSERIAL_H_

#include <SoftwareSerial.h>

class MySerial: public SoftwareSerial {
private:
  int param;

public:

  MySerial(uint8_t receivePin, uint8_t transmitPin) :
      SoftwareSerial(receivePin, transmitPin, false) {
    param = 0;
  }

  void resend(char c) {
    write(c);
  }
};
#endif

MySerial.ino
#include "MySerial.h"

MySerial mySerial(6, 7);

void setup() {
  mySerial.begin(9600);
}

void loop() {
  if (mySerial.available()) {
    int c = mySerial.read();
    mySerial.resend(c);
  }
}


42225: <p>How should I inherit from <code>Stream</code>, for creating a new class <code>MySerial</code> able to be initialized from a <code>Stream0</code> instance?.</p>

<p>The error so far is: <code>"cannot declare variable 'mySerial' to be of abstract type 'MySerial'"</code>.</p>

<p>If I make a class <code>MySerial</code> not inheriting, but adding a property <code>Stream</code>, everything works fine, except the new call mechanism for the <code>resend()</code> function, created to accept <code>Stream</code> instances.</p>

<p>EDIT: This is the edited code. Current error is: <code>"expected unqualified-id before '=' token"</code>.</p>

<p><em>MySerial.h</em>
</p>

<pre class="lang-cpp prettyprint-override"><code>class MySerial:public Stream{
    private:
        int param;
    public:
        MySerial(){}; // OK
        MySerial(Stream &amp;Serial0){MySerial=&amp;Serial0} // Here is the question
        // Stream Implementation
        int available(){return available();}
        int read(){return read();}
        int peek(){return peek();}
        size_t write(uint8_t c){return write(c);}
        using Print::write; 
};
</code></pre>

<p><em>MySerial.ino</em></p>

<pre class="lang-cpp prettyprint-override"><code>#include &lt;MySerial.h&gt;
#include &lt;SoftwareSerial.h&gt;

SoftwareSerial swSerial(6,7);
MySerial mySerial(swSerial);

void setup(){}
void loop(){    
    if (mySerial.available()){
        c=mySerial.read();
        resend(mySerial,c);
    }
}
// This function should accept any Stream: SoftwareSerial, MySerial, Serial...
void resend(Stream &amp;Stream0, char c){
    Stream0.write(c);
}
</code></pre>
 37622: <p>The <code>Stream</code> class has pure virtual methods which must be implemented in derived not abstract class.</p>

<p>The pure virtual method from base class <code>Print</code> is:</p>

<pre><code>virtual size_t write(uint8_t) = 0;
</code></pre>

<p>The pure virtual methods from <code>Stream</code> are:</p>

<pre><code>virtual int available() = 0;
virtual int read() = 0;
virtual int peek() = 0;
</code></pre>

<p>additionally add in your class the line</p>

<pre><code>using Print::write; 
</code></pre>

<p>to pull in overloaded methods write(str) and write(buf, size) from<code>Print</code></p>

<p><a href="https://github.com/jandrassy/TelnetStream/blob/master/src/TelnetStream.h" rel="nofollow noreferrer">Here</a> I have an example of a simple class derived from <code>Stream</code>.</p>

<hr>

<p>EDIT: Most of your question seemed to focus on wrapping some Stream implementation. Now I see that you maybe want to enhance the SoftwareSerial class and add a new method in the inherited class. It is simple:</p>

<p>MySerial.h</p>

<pre><code>#ifndef _MYSERIAL_H_
#define _MYSERIAL_H_

#include &lt;SoftwareSerial.h&gt;

class MySerial: public SoftwareSerial {
private:
  int param;

public:

  MySerial(uint8_t receivePin, uint8_t transmitPin) :
      SoftwareSerial(receivePin, transmitPin, false) {
    param = 0;
  }

  void resend(char c) {
    write(c);
  }
};
#endif
</code></pre>

<p>MySerial.ino</p>

<pre><code>#include "MySerial.h"

MySerial mySerial(6, 7);

void setup() {
  mySerial.begin(9600);
}

void loop() {
  if (mySerial.available()) {
    int c = mySerial.read();
    mySerial.resend(c);
  }
}
</code></pre>
