Ahora suponga que desea crear un objeto del tipo ifstream que no solo abre un fichero sino que también guarde el nombre del fichero. Puede usar la composición e alojar un objeto ifstream y un string en la nueva clase:

//: C14:FName1.cpp
// An fstream with a file name
#include "../require.h"
#include <iostream>
#include <fstream>
#include <string>
using namespace std;

class FName1 {
  ifstream file;
  string fileName;
  bool named;
public:
  FName1() : named(false) {}
  FName1(const string& fname) 
    : fileName(fname), file(fname.c_str()) {
    assure(file, fileName);
    named = true;
  }
  string name() const { return fileName; }
  void name(const string& newName) {
    if(named) return; // Don't overwrite
    fileName = newName;
    named = true;
  }
  operator ifstream&() { return file; }
};

int main() {
  FName1 file("FName1.cpp");
  cout << file.name() << endl;
  // Error: close() not a member:
//!  file.close();
} ///:~

Sin embargo, existe un problema. Se intenta permitir el uso de un objeto FName1 en cualquier lugar dónde se utilice un objeto ifstream, incluyendo una conversión automática del tipo desde FName1 a ifstream&. Pero en main, la línea

file.close();

no compilará porque la conversión automática de tipo sólo ocurre cuando se llama a la función, no durante la selección del miembro. Por ello, esta manera no funcionará.

Una segunda manera es añadir la definición Close() a FName1:

void close() { file.close(); }

Esto funcionará si sólo existen unas cuantas funciones a las que se desea hacer funcionar como una clase ifstream. En este caso, solo una parte de la clase y la composición apropiada.

Pero ¿qué ocurre si se quiere que todo funcione cómo la clase deseada? A eso se le llama subtipos porque esta creando un nuevo tipo desde uno ya existente y lo que se quiere es que el nuevo tipo tenga la misma interfaz que el tipo existente (además de otras funciones que se deseen añadir) para que se pueda utilizar en cualquier lugar donde se utilizaba el tipo existente. Aquí es dónde la herencia es esencial. Puede ver que el subtipo resuelve perfectamente el problema anterior:

//: C14:FName2.cpp
// Subtyping solves the problem
#include "../require.h"
#include <iostream>
#include <fstream>
#include <string>
using namespace std;

class FName2 : public ifstream {
  string fileName;
  bool named;
public:
  FName2() : named(false) {}
  FName2(const string& fname)
    : ifstream(fname.c_str()), fileName(fname) {
    assure(*this, fileName);
    named = true;
  }
  string name() const { return fileName; }
  void name(const string& newName) {
    if(named) return; // Don't overwrite
    fileName = newName;
    named = true;
  }
};

int main() {
  FName2 file("FName2.cpp");
  assure(file, "FName2.cpp");
  cout << "name: " << file.name() << endl;
  string s;
  getline(file, s); // These work too!
  file.seekg(-200, ios::end);
  file.close();
} ///:~

Ahora cualquier función que este disponible para el objeto sfstream también esta disponible para el objeto FName2. Asimismo se observan funciones no miembro como getline() que esperan un objeto ifstream y que pueden funcionar con un objeto FName2. Esto es porque FName2 es un tipo de ifstream; esto no significa simplemente que lo contiene. Esto es un tema muy importante que será explorado al final de este capitulo y el siguiente.

Puede heredar utilizando una clase base de forma privada borrando public en la lista de la clase base o explícitamente utilizando private (definitivamente la mejor política a tomar pues indica al usuario lo que desea hacer). Cuando se hereda de forma privada, esta "implementado en términos de", esto es, se esta creando una nueva clase que tiene todos los datos y funcionalidad de la clase base, pero la funcionalidad esta oculta, solo una parte de capa de implementación. La clase derivada no tiene acceso a la capa de funcionalidad y un objeto no puede ser creado como instancia de la clase base (como ocurrió en FName2.cpp).

Se sorprenderá del propósito de la herencia privada, porque la alternativa, usar la composición para crear un objeto privado en la nueva clase parece más apropiada. La herencia privada esta incluida para completar el lenguaje pero para reducir confusión, normalmente se usará la composición en vez de la herencia privada. Sin embargo, existen ocasiones donde se desea el mismo interfaz como la clase base y anular tratamiento del objeto. La herencia privada proporciona esta habilidad.

//: C14:PrivateInheritance.cpp
class Pet {
public:
  char eat() const { return 'a'; }
  int speak() const { return 2; }
  float sleep() const { return 3.0; }
  float sleep(int) const { return 4.0; }
};

class Goldfish : Pet { // Private inheritance
public:
  using Pet::eat; // Name publicizes member
  using Pet::sleep; // Both members exposed
};

int main() {
  Goldfish bob;
  bob.eat();
  bob.sleep();
  bob.sleep(1);
//! bob.speak();// Error: private member function
} ///:~