Erreur si la surcharge d'un operateur n'est pas friend

    /**
     * @brief Opérateur libre d'addition de deux matrices.
     * @param[in] lhs La matrice de gauche. 
     * @param[in] rhs La matrice de droite.
     * @pre Les deux matrices doivent être de même dimension.
     * @return Le résultat de l'addition des deux matrices.
     */
    friend Matrice operator+(Matrice lhs, Matrice const & rhs);

Matrice operator+(Matrice lhs, Matrice const & rhs)
{
    lhs += rhs;
    return lhs;
}

#ifndef Matrix_H
#define Matrix_H

#include <vector>
#include <tuple>

class Matrice
{
    public:
        Matrice() = delete;
        Matrice(int nb_row, int nb_column, int valeur = 0);
        Matrice(const Matrice& A);

        void const display();

        double const & operator()(int x, int y) const;
        double& operator()(int x, int y);

        std::tuple<int,int> size() const;

        Matrice& operator=(const Matrice& A);
        Matrice& operator+=(const Matrice& A);

        friend Matrice operator+(Matrice A, const Matrice& B);


    private:
        std::size_t offset(std::size_t ligne, std::size_t colonne) const noexcept;

        std::size_t m_nb_lignes;
        std::size_t m_nb_colonnes;
        std::vector<double> m_matrice;

};
#endif

#include "Matrice.hpp"

#include <iostream>
#include <cassert>
#include <vector>
#include <tuple>

Matrice::Matrice(int nb_row, int nb_column, int valeur) : m_nb_lignes(nb_row), m_nb_colonnes(nb_column)
{
    assert( ( nb_row > 0 || nb_column > 0 ) && "Number of row and column need to be > 0.");
    m_matrice.resize(nb_row * nb_column, valeur); 
}

Matrice::Matrice(const Matrice& A) 
    : m_nb_lignes(A.m_nb_lignes), m_nb_colonnes(A.m_nb_colonnes), m_matrice(A.m_matrice)
{
    // Nothing
}

// --- ---
// Member functions
// --- ---

std::size_t Matrice::offset(std::size_t ligne, std::size_t colonne) const noexcept
{
    return colonne * m_nb_lignes + ligne;
}

double const & Matrice::operator()(int x, int y) const
{
    return m_matrice[offset(x, y)];
}

double& Matrice::operator()(int x, int y)
{
    return m_matrice[offset(x, y)];
}

std::tuple<int,int> Matrice::size() const
{
    return std::make_tuple(m_nb_lignes, m_nb_colonnes);
}


void const Matrice::display()
{
    for (int i = 0; i < m_nb_lignes; i++)
    {
        for (int j = 0; j < m_nb_colonnes; j++)
        {
            std::cout << (*this)(i,j) << ' ';
        }
        std::cout << std::endl;
    }
}

Matrice& Matrice::operator=(const Matrice& A)
{
    m_nb_lignes = A.m_nb_lignes;
    m_nb_colonnes = A.m_nb_colonnes;
    m_matrice = A.m_matrice;
    return *this;
}

Matrice& Matrice::operator+=(const Matrice& A)
{
    assert( (*this).size() == A.size() && " Les matrices doivent avoir la même taille.");
    
    for (int i=0; i < m_nb_lignes; i++)
    {
        for (int j=0; j < m_nb_colonnes; j++)
        {
            (*this)(i,j) += A(i,j);
        }
    }
    return *this;
    
}

// --- ---
// Free functions
// --- ---

Matrice operator+(Matrice A, const Matrice& B)
{
    A += B;
    return A;
}

class Fraction
{
public:
    Fraction& operator+=(Fraction const & fraction) noexcept;

private:
    int m_numerateur { 0 };
    int m_denominateur { 1 };
};

Fraction& Fraction::operator+=(Fraction const & fraction) noexcept
{
    m_numerateur = m_numerateur * fraction.m_denominateur + fraction.m_numerateur * m_denominateur;
    m_denominateur *= fraction.m_denominateur;
    return *this;
}

// L'argument lhs est recopié, donc on peut le modifier sans problème.
Fraction operator+(Fraction lhs, Fraction const & rhs) noexcept
{
    lhs += rhs;
    return lhs;
}