Esta é a maneira correta de escrever uma série de ponteiros?

Desculpe por surpreendê-lo:
Nenhum dos exemplos que você deu deve ser considerado como a "maneira correta" de lidar com coleções de classes em c ++.

Além disso, se possível, não mencione std :: array ou std :: vector, ainda sou muito novo

Não, esse é o caminho errado puxando a égua. O uso apropriado de ponteiros brutos e matrizes brutas certamente está além de suas capacidades, se você não souber como lidar com eles std::arrayou std::vectorprincipalmente.

Suponha que sua Employeeclasse se pareça com

struct Employee {
    std::string surname_;
    std::string firstname_;
    enum Gender {
       Female = 'F' ,
       Male = 'M' ,
       Unxpecified = 'X'
    } gender_;
};

e você tem uma sobrecarga para o std::operator>>()

std::istream& operator>>(std::istream& is, Employee& employee) {
    char genderSymbol;
    is >> employee.surname_ >> employee.firstname_ >> genderSymbol;
    switch(genderSymbol) {
    case 'F':
    case 'M':
    case 'X':
         employee.gender_ = (Employee::Gender)genderSymbol;
         break;
    default:
        is.setstate(std::ios_base::failbit);
        break;
    }
}

Uma maneira boa e idiomática de representar essa Employeematriz seria usar um

std::vector<Employee> employeeArr;

e preencha em um loop:

Employee employee;
while(std::cin >> employee) {
    employeeArr.emplace_back(employee);
}

Se você realmente precisa de ponteiros (referências), pode considerar o uso de ponteiros inteligentes, conforme fornecido com as classes do utilitário Dynamic Memory Management .

Por exemplo, você pode decidir ter um

std::vector<std::unique_ptr<Employee>> employeeArr;

e inicializá-lo como

while(std::cin >> surname >> firstname >> gender) {
    employeeArr.emplace_back(std::make_unique<Employee>(surname , firstname , gender));
}

Isso é levado em consideração se você deseja gerenciar pools de instâncias de classe organizadas hierarquicamente, como:

struct Employee {
    virtual ~Employee() {}
    std::string surname_;
    std::string firstname_;
    enum Gender {
       Female = 'F' ,
       Male = 'M' ,
       Unxpecified = 'X'
    } gender_;
};

struct IForeman : Employee {
    virtual std::vector<const Employee const*> TeamMembers() const = 0;
    virtual void AddTeamMember(const Employee const* member) = 0;
};

class Foreman : public IForeman {
     str::vector<const Employee const*> teamMembers_;
public:
     std::vector<const Employee const*> TeamMembers() const {
         return teamMembers_;
     }
     void AddTeamMember(const Employee const* member) {
         teamMembers_.push_back(member);
     }
};

Considere distribuir ponteiros próprios ou compartilhados para conexões relacionadas usando constponteiros simples .