A documentação do iOS da Apple está incorreta sobre a substituição de classes registradas anteriormente com o mesmo identificador de reutilização pela nova cellClass?

Embora o código de exemplo publicado seja uma abordagem ruim para começar, parece que a documentação não está correta. Ou não está nada claro o que deveria acontecer.

Vejamos este exemplo (NÃO usando SnapKit)...

Criaremos uma classe de célula "Base":

class CellBase: UITableViewCell {
    
    let label = UILabel()
    
    override init(style: UITableViewCell.CellStyle, reuseIdentifier: String?) {
        super.init(style: style, reuseIdentifier: reuseIdentifier)
        label.font = UIFont.systemFont(ofSize: 20, weight: .regular)
        
        label.translatesAutoresizingMaskIntoConstraints = false
        contentView.addSubview(label)
        
        let g = contentView.layoutMarginsGuide

        let h = label.heightAnchor.constraint(equalToConstant: 44.0)
        h.priority = .required - 1
        
        NSLayoutConstraint.activate([
            label.topAnchor.constraint(equalTo: g.topAnchor),
            label.leadingAnchor.constraint(equalTo: g.leadingAnchor),
            label.trailingAnchor.constraint(equalTo: g.trailingAnchor),
            label.bottomAnchor.constraint(equalTo: g.bottomAnchor),
            h,
        ])
    }
    
    required init?(coder: NSCoder) {
        fatalError("init(coder:) has not been implemented")
    }
}

e duas subclasses - CellAe CellB(cores diferentes para facilitar a visualização de qual delas está sendo usada):

class CellA: CellBase {
    
    override init(style: UITableViewCell.CellStyle, reuseIdentifier: String?) {
        super.init(style: style, reuseIdentifier: reuseIdentifier)
        
        label.backgroundColor = .yellow
        contentView.backgroundColor = .systemYellow
    }
    
    required init?(coder: NSCoder) {
        fatalError("init(coder:) has not been implemented")
    }
}

class CellB: CellBase {
    
    override init(style: UITableViewCell.CellStyle, reuseIdentifier: String?) {
        super.init(style: style, reuseIdentifier: reuseIdentifier)
        
        label.backgroundColor = .cyan
        contentView.backgroundColor = .systemBlue
    }
    
    required init?(coder: NSCoder) {
        fatalError("init(coder:) has not been implemented")
    }
}

Ao subclassificar as células, podemos usar um cellForRowAtif/else:

func tableView(_ tableView: UITableView, cellForRowAt indexPath: IndexPath) -> UITableViewCell {
    let cell = tableView.dequeueReusableCell(withIdentifier: "cellBase") as! CellBase
    cell.label.text = "Row: \(indexPath.row) - use Cell A: \(useCellA)"
    return cell
}

Se nos registrarmos CellAassim:

tableView.register(CellA.self, forCellReuseIdentifier: "cellBase")

um layout típico será parecido com este:

Ou, se registrarmos CellBassim:

tableView.register(CellB.self, forCellReuseIdentifier: "cellBase")

obtemos esta saída:

Então, vamos adicionar um botão na parte inferior para alternar o registro:

class ChangeCellRegVC: UIViewController, UITableViewDataSource {
    
    let tableView = UITableView(frame: .zero, style: .plain)
    let btn = UIButton()
    
    var useCellA: Bool = true
    
    override func viewDidLoad() {
        super.viewDidLoad()
        
        view.backgroundColor = .systemBackground
    
        btn.setTitle("Switch to Cell B", for: [])
        btn.backgroundColor = .systemRed
        btn.setTitleColor(.white, for: .normal)
        btn.setTitleColor(.lightGray, for: .highlighted)
        btn.addTarget(self, action: #selector(btnTap(_:)), for: .touchUpInside)
        
        tableView.translatesAutoresizingMaskIntoConstraints = false
        btn.translatesAutoresizingMaskIntoConstraints = false
        view.addSubview(tableView)
        view.addSubview(btn)

        let g = view.safeAreaLayoutGuide
        NSLayoutConstraint.activate([
            tableView.topAnchor.constraint(equalTo: g.topAnchor),
            tableView.leadingAnchor.constraint(equalTo: g.leadingAnchor),
            tableView.trailingAnchor.constraint(equalTo: g.trailingAnchor),

            btn.topAnchor.constraint(equalTo: tableView.bottomAnchor, constant: 20.0),
            btn.leadingAnchor.constraint(equalTo: g.leadingAnchor, constant: 40.0),
            btn.trailingAnchor.constraint(equalTo: g.trailingAnchor, constant: -40.0),
            btn.bottomAnchor.constraint(equalTo: g.bottomAnchor),
        ])

        tableView.register(CellA.self, forCellReuseIdentifier: "cellBase")
        tableView.dataSource = self
    }

    @objc func btnTap(_ sender: UIButton) {
        useCellA.toggle()
        if useCellA {
            print("register CellA")
            tableView.register(CellA.self, forCellReuseIdentifier: "cellBase")
        } else {
            print("register CellB")
            tableView.register(CellB.self, forCellReuseIdentifier: "cellBase")
        }

        tableView.reloadData()

        // update button title
        btn.setTitle("Switch to Cell \(useCellA ? "B" : "A")", for: [])
    }

    func tableView(_ tableView: UITableView, numberOfRowsInSection section: Int) -> Int {
        100
    }
    
    func tableView(_ tableView: UITableView, cellForRowAt indexPath: IndexPath) -> UITableViewCell {
        let cell = tableView.dequeueReusableCell(withIdentifier: "cellBase") as! CellBase
        cell.label.text = "Row: \(indexPath.row) - use Cell A: \(useCellA)"
        return cell
    }
}

No lançamento, fica assim:

Se tocarmos no botão "Alternar para...", chamaremos tableView.register(...)novamente, alternando entre CellAe CellB , and call reloadData()` (código relevante):

@objc func btnTap(_ sender: UIButton) {
    useCellA.toggle()
    if useCellA {
        print("register CellA")
        tableView.register(CellA.self, forCellReuseIdentifier: "cellBase")
    } else {
        print("register CellB")
        tableView.register(CellB.self, forCellReuseIdentifier: "cellBase")
    }
    
    tableView.reloadData()
    
    // update button title
    btn.setTitle("Switch to Cell \(useCellA ? "B" : "A")", for: [])
}

Então, o que ganhamos ao tocar um botão?

Claramente, as células foram recarregadas, pois "true" mudou para "false"... mas elas ainda estão sendo retiradas da filaCellA !

Então, vamos rolar algumas linhas para cima:

A visualização de tabela teve que criar 3 novas células em .dequeueReusableCell, usando CellBa classe conforme esperado... mas começando em "Linha: 14" ela volta a reutilizar CellA !

Se continuarmos rolando:

vemos que a visualização de tabela agora tem 11 CellAinstâncias e 3 CellBinstâncias em sua "fila reutilizável"... e não importa qual classe registramos atualmente.

Observe também... os documentos afirmam:

Você pode especificar nil para cellClass se quiser cancelar o registro da classe do identificador de reutilização especificado.

Mas, se fizermos o carregamento inicial, executamos este código:

tableView.register(nil as UINib?, forCellReuseIdentifier: "cellBase")
tableView.reloadData()

cellForRowAtserá chamado para cada uma das células visíveis e elas ainda serão atualizadas!

Se tentarmos rolar, o aplicativo travará cellForRowAtcom a mensagem "Erro fatal: encontrado inesperadamente nulo ao desembrulhar um valor opcional".

A falha na rolagem faz sentido, embora o recarregamento de células já enfileiradas não faça.