diff --git a/autotest/cpp/test_gdal_algorithm.cpp b/autotest/cpp/test_gdal_algorithm.cpp
index 31acac4b3c89..3ce37e480dc8 100644
--- a/autotest/cpp/test_gdal_algorithm.cpp
+++ b/autotest/cpp/test_gdal_algorithm.cpp
@@ -101,6 +101,170 @@ TEST_F(test_gdal_algorithm, GDALAlgorithmArgDecl_SetMaxCount)
               2);
 }
 
+class MyAlgorithmWithDummyRun : public GDALAlgorithm
+{
+  public:
+    MyAlgorithmWithDummyRun(const std::string &name = "test",
+                            const std::string &description = "",
+                            const std::string &url = "https://example.com")
+        : GDALAlgorithm(name, description, url)
+    {
+    }
+
+    bool RunImpl(GDALProgressFunc, void *) override
+    {
+        return true;
+    }
+};
+
+TEST_F(test_gdal_algorithm, GDALAlgorithmArg_SetDefault)
+{
+
+    class MyAlgorithm : public MyAlgorithmWithDummyRun
+    {
+      public:
+        MyAlgorithm()
+        {
+            {
+                bool v;
+                auto &arg = AddArg("", 0, "", &v);
+                arg.SetDefault(true);
+                EXPECT_TRUE(arg.GetDefault<bool>());
+
+                CPLErrorStateBackuper oBackuper(CPLQuietErrorHandler);
+                CPLErrorReset();
+                arg.SetDefault("invalid");
+                EXPECT_EQ(CPLGetLastErrorType(), CE_Failure);
+            }
+
+            {
+                int v;
+                auto &arg = AddArg("", 0, "", &v);
+                arg.SetDefault(5);
+                EXPECT_EQ(arg.GetDefault<int>(), 5);
+
+                CPLErrorStateBackuper oBackuper(CPLQuietErrorHandler);
+                CPLErrorReset();
+                arg.SetDefault("invalid");
+                EXPECT_EQ(CPLGetLastErrorType(), CE_Failure);
+            }
+
+            {
+                double v;
+                auto &arg = AddArg("", 0, "", &v);
+                arg.SetDefault(4.5);
+                EXPECT_EQ(arg.GetDefault<double>(), 4.5);
+
+                arg.SetDefault(5);
+                EXPECT_EQ(arg.GetDefault<double>(), 5);
+
+                arg.SetDefault(2.5f);
+                EXPECT_EQ(arg.GetDefault<double>(), 2.5);
+
+                CPLErrorStateBackuper oBackuper(CPLQuietErrorHandler);
+                CPLErrorReset();
+                arg.SetDefault("invalid");
+                EXPECT_EQ(CPLGetLastErrorType(), CE_Failure);
+            }
+
+            {
+                std::string v;
+                auto &arg = AddArg("", 0, "", &v);
+
+                arg.SetDefault("ab");
+                EXPECT_STREQ(arg.GetDefault<std::string>().c_str(), "ab");
+
+                arg.SetDefault(std::string("cd"));
+                EXPECT_STREQ(arg.GetDefault<std::string>().c_str(), "cd");
+
+                CPLErrorStateBackuper oBackuper(CPLQuietErrorHandler);
+                CPLErrorReset();
+                arg.SetDefault(0);
+                EXPECT_EQ(CPLGetLastErrorType(), CE_Failure);
+            }
+
+            {
+                std::vector<int> v;
+                auto &arg = AddArg("", 0, "", &v);
+                arg.SetDefault(5);
+                std::vector<int> expected{5};
+                EXPECT_EQ(arg.GetDefault<std::vector<int>>(), expected);
+
+                CPLErrorStateBackuper oBackuper(CPLQuietErrorHandler);
+                CPLErrorReset();
+                arg.SetDefault("invalid");
+                EXPECT_EQ(CPLGetLastErrorType(), CE_Failure);
+            }
+
+            {
+                std::vector<double> v;
+                auto &arg = AddArg("", 0, "", &v);
+                arg.SetDefault(4.5);
+                {
+                    std::vector<double> expected{4.5};
+                    EXPECT_EQ(arg.GetDefault<std::vector<double>>(), expected);
+                }
+
+                arg.SetDefault(5);
+                {
+                    std::vector<double> expected{5};
+                    EXPECT_EQ(arg.GetDefault<std::vector<double>>(), expected);
+                }
+
+                arg.SetDefault(2.5f);
+                {
+                    std::vector<double> expected{2.5};
+                    EXPECT_EQ(arg.GetDefault<std::vector<double>>(), expected);
+                }
+
+                CPLErrorStateBackuper oBackuper(CPLQuietErrorHandler);
+                CPLErrorReset();
+                arg.SetDefault("invalid");
+                EXPECT_EQ(CPLGetLastErrorType(), CE_Failure);
+            }
+
+            {
+                std::vector<std::string> v;
+                auto &arg = AddArg("", 0, "", &v);
+
+                arg.SetDefault("ab");
+                {
+                    std::vector<std::string> expected{"ab"};
+                    EXPECT_EQ(arg.GetDefault<std::vector<std::string>>(),
+                              expected);
+                }
+
+                CPLErrorStateBackuper oBackuper(CPLQuietErrorHandler);
+                CPLErrorReset();
+                arg.SetDefault(0);
+                EXPECT_EQ(CPLGetLastErrorType(), CE_Failure);
+            }
+
+            {
+                GDALArgDatasetValue v;
+                auto &arg = AddArg("", 0, "", &v);
+
+                CPLErrorStateBackuper oBackuper(CPLQuietErrorHandler);
+                CPLErrorReset();
+                arg.SetDefault(0);
+                EXPECT_EQ(CPLGetLastErrorType(), CE_Failure);
+            }
+
+            {
+                std::vector<GDALArgDatasetValue> v;
+                auto &arg = AddArg("", 0, "", &v);
+
+                CPLErrorStateBackuper oBackuper(CPLQuietErrorHandler);
+                CPLErrorReset();
+                arg.SetDefault(0);
+                EXPECT_EQ(CPLGetLastErrorType(), CE_Failure);
+            }
+        }
+    };
+
+    MyAlgorithm alg;
+}
+
 TEST_F(test_gdal_algorithm, GDALAlgorithmArg_Set)
 {
     {
@@ -783,22 +947,6 @@ TEST_F(test_gdal_algorithm, SetIsCRSArg_wrong_type)
     }
 }
 
-class MyAlgorithmWithDummyRun : public GDALAlgorithm
-{
-  public:
-    MyAlgorithmWithDummyRun(const std::string &name = "test",
-                            const std::string &description = "",
-                            const std::string &url = "https://example.com")
-        : GDALAlgorithm(name, description, url)
-    {
-    }
-
-    bool RunImpl(GDALProgressFunc, void *) override
-    {
-        return true;
-    }
-};
-
 TEST_F(test_gdal_algorithm, wrong_long_name_dash)
 {
     class MyAlgorithm : public MyAlgorithmWithDummyRun
diff --git a/gcore/gdalalgorithm.h b/gcore/gdalalgorithm.h
index 3190cc5f4d1b..0e5afec90090 100644
--- a/gcore/gdalalgorithm.h
+++ b/gcore/gdalalgorithm.h
@@ -618,54 +618,104 @@ class CPL_DLL GDALAlgorithmArgDecl final
     template <class T> GDALAlgorithmArgDecl &SetDefault(const T &value)
     {
         m_hasDefaultValue = true;
-        if constexpr (std::is_same_v<T, std::string>)
-        {
-            if (m_type == GAAT_STRING_LIST)
-            {
-                m_defaultValue = std::vector<std::string>{value};
-                return *this;
-            }
-        }
-        else if constexpr (std::is_same_v<T, int>)
-        {
-            if (m_type == GAAT_REAL)
-            {
-                m_defaultValue = static_cast<double>(value);
-                return *this;
-            }
-            else if (m_type == GAAT_INTEGER_LIST)
-            {
-                m_defaultValue = std::vector<int>{value};
-                return *this;
-            }
-            else if (m_type == GAAT_REAL_LIST)
-            {
-                m_defaultValue =
-                    std::vector<double>{static_cast<double>(value)};
-                return *this;
-            }
-        }
-        else if constexpr (std::is_same_v<T, double>)
+        try
         {
-            if (m_type == GAAT_REAL_LIST)
+            switch (m_type)
             {
-                m_defaultValue = std::vector<double>{value};
-                return *this;
+                case GAAT_BOOLEAN:
+                {
+                    if constexpr (std::is_same_v<T, bool>)
+                    {
+                        m_defaultValue = value;
+                        return *this;
+                    }
+                    break;
+                }
+
+                case GAAT_STRING:
+                {
+                    if constexpr (std::is_same_v<T, std::string>)
+                    {
+                        m_defaultValue = value;
+                        return *this;
+                    }
+                    break;
+                }
+
+                case GAAT_INTEGER:
+                {
+                    if constexpr (std::is_same_v<T, int>)
+                    {
+                        m_defaultValue = value;
+                        return *this;
+                    }
+                    break;
+                }
+
+                case GAAT_REAL:
+                {
+                    if constexpr (std::is_assignable_v<double &, T>)
+                    {
+                        m_defaultValue = static_cast<double>(value);
+                        return *this;
+                    }
+                    break;
+                }
+
+                case GAAT_STRING_LIST:
+                {
+                    if constexpr (std::is_same_v<T, std::string>)
+                    {
+                        m_defaultValue = std::vector<std::string>{value};
+                        return *this;
+                    }
+                    break;
+                }
+
+                case GAAT_INTEGER_LIST:
+                {
+                    if constexpr (std::is_same_v<T, int>)
+                    {
+                        m_defaultValue = std::vector<int>{value};
+                        return *this;
+                    }
+                    break;
+                }
+
+                case GAAT_REAL_LIST:
+                {
+                    if constexpr (std::is_assignable_v<double &, T>)
+                    {
+                        m_defaultValue =
+                            std::vector<double>{static_cast<double>(value)};
+                        return *this;
+                    }
+                    break;
+                }
+
+                case GAAT_DATASET:
+                case GAAT_DATASET_LIST:
+                    break;
             }
         }
-        try
-        {
-            m_defaultValue = value;
-        }
         catch (const std::bad_variant_access &)
         {
-            CPLError(CE_Failure, CPLE_AppDefined,
-                     "Argument %s: SetDefault(): unexpected type for value",
-                     GetName().c_str());
+            // should not happen
+            // fallthrough
         }
+        CPLError(CE_Failure, CPLE_AppDefined,
+                 "Argument %s: SetDefault(): unexpected type for value",
+                 GetName().c_str());
         return *this;
     }
 
+    /** Declare a default value for the argument.
+     */
+    GDALAlgorithmArgDecl &SetDefault(const char *value)
+    {
+        return SetDefault(std::string(value));
+    }
+
     /** Declare the minimum number of values for the argument. Defaults to 0.
      * Only applies to list type of arguments.
      * Setting it to non-zero does *not* make the argument required. It just
@@ -1835,36 +1885,47 @@ class CPL_DLL GDALInConstructionAlgorithmArg final : public GDALAlgorithmArg
         if constexpr (!std::is_same_v<T, GDALArgDatasetValue> &&
                       !std::is_same_v<T, std::vector<GDALArgDatasetValue>>)
         {
-            switch (m_decl.GetType())
+            try
             {
-                case GAAT_BOOLEAN:
-                    *std::get<bool *>(m_value) = m_decl.GetDefault<bool>();
-                    break;
-                case GAAT_STRING:
-                    *std::get<std::string *>(m_value) =
-                        m_decl.GetDefault<std::string>();
-                    break;
-                case GAAT_INTEGER:
-                    *std::get<int *>(m_value) = m_decl.GetDefault<int>();
-                    break;
-                case GAAT_REAL:
-                    *std::get<double *>(m_value) = m_decl.GetDefault<double>();
-                    break;
-                case GAAT_STRING_LIST:
-                    *std::get<std::vector<std::string> *>(m_value) =
-                        m_decl.GetDefault<std::vector<std::string>>();
-                    break;
-                case GAAT_INTEGER_LIST:
-                    *std::get<std::vector<int> *>(m_value) =
-                        m_decl.GetDefault<std::vector<int>>();
-                    break;
-                case GAAT_REAL_LIST:
-                    *std::get<std::vector<double> *>(m_value) =
-                        m_decl.GetDefault<std::vector<double>>();
-                    break;
-                case GAAT_DATASET:
-                case GAAT_DATASET_LIST:
-                    break;
+                switch (m_decl.GetType())
+                {
+                    case GAAT_BOOLEAN:
+                        *std::get<bool *>(m_value) = m_decl.GetDefault<bool>();
+                        break;
+                    case GAAT_STRING:
+                        *std::get<std::string *>(m_value) =
+                            m_decl.GetDefault<std::string>();
+                        break;
+                    case GAAT_INTEGER:
+                        *std::get<int *>(m_value) = m_decl.GetDefault<int>();
+                        break;
+                    case GAAT_REAL:
+                        *std::get<double *>(m_value) =
+                            m_decl.GetDefault<double>();
+                        break;
+                    case GAAT_STRING_LIST:
+                        *std::get<std::vector<std::string> *>(m_value) =
+                            m_decl.GetDefault<std::vector<std::string>>();
+                        break;
+                    case GAAT_INTEGER_LIST:
+                        *std::get<std::vector<int> *>(m_value) =
+                            m_decl.GetDefault<std::vector<int>>();
+                        break;
+                    case GAAT_REAL_LIST:
+                        *std::get<std::vector<double> *>(m_value) =
+                            m_decl.GetDefault<std::vector<double>>();
+                        break;
+                    case GAAT_DATASET:
+                    case GAAT_DATASET_LIST:
+                        break;
+                }
+            }
+            catch (const std::bad_variant_access &)
+            {
+                // I don't think that can happen, but Coverity Scan thinks so
+                CPLError(CE_Failure, CPLE_AppDefined,
+                         "Argument %s: SetDefault(): unexpected type for value",
+                         GetName().c_str());
             }
         }
         return *this;