I would like to reference two earlier posts:

我想引用两个较早的文章：

why-is-comparing-two-parameters-of-a-constexpr-function-not-a-constant-condition

Why-is-comparing-two-parameters-of-a-constexpr-function-not-a-constant-condition

how-does-this-function-template-deduce-the-size-of-an-array

How-does-this-function-template-deduce-the-size-of-an-array

In the first discussion, it has been pointed out that the compilation error

在第一个讨论中，已经指出了编译错误

error: non-constant condition for static assertion

is due to the fact that the constexpr function under consideration could be invoked with arguments evaluated during run-time.

这是因为可以使用在运行时计算的参数来调用所考虑的constexpr函数。

In the second discussion, it has been pointed out that the template function method for getting at the size of the template array, works due to template argument type deduction by the compiler, which happens during compilation.

在第二个讨论中，已经指出，用于获取模板数组大小的模板函数方法是由于编译器在编译期间发生的模板参数类型推断而起作用的。

The following code gives me this error for static assertion:

下面的代码给出了静态断言的这个错误：

In file included from main.cpp:1:
classA.h: In instantiation of ‘void doSomething(A<T> (&)[2]) [with T = int; array2As<T> = A<int> [2]]’:
main.cpp:6:18:   required from here
classA.h:65:20: error: non-constant condition for static assertion
   65 |    static_assert(2 == sz, "Compilation error: array must have exactly 2 elements");
      |                  ~~^~~~~
compilation terminated due to -Wfatal-errors

//classA.h

#include <type_traits>
#include <cstddef>
//#include <iterator>
#include <iostream>

using std::is_same;
//using std::size;
using std::size_t;
using std::cout;
using std::endl;

template<typename T> class A;
template<typename T>
using array2As = A<T>[2];

template<typename T> 
void doSomething (array2As<T>&);

template<template<typename>class A, typename T, size_t N>
constexpr size_t cal_size(const A<T>(&)[N]){
 return N;
}

template<typename T>
class A{
  public:
  A(T);
  private:
  friend void doSomething<>(array2As<T>&);
  A()=delete;
  A(const A&)=delete; 
  A& operator=(const A&)=delete;
  T elem;
};

template<typename T>
A<T>::A(T elem){
  static_assert(is_same<T,int>::value || is_same<T,double>::value, "Compilation error: type must be int or double");
  this->elem = elem;
}

template<typename T> void doSomething (array2As<T>& a){
auto sz = cal_size(a);
   cout << sz << endl;
   static_assert(2 == sz, "Compilation error: array must have exactly 2 elements");
  
  const auto& obj1 = a[0];
  cout << obj1.elem << endl;
  const auto& obj2 = a[1];
  cout << obj2.elem << endl;
 return;
}

//main.cpp

#include "classA.h"

int main (){
 
 array2As<int> a = {A(5),A(7)};
 doSomething<int>(a);
 array2As<double> b = {A(1.2),A(6.3)};
 doSomething<double>(b);

 return 0;
}

The methods involved, i.e., cal_size() and doSomething() are function templates themselves, so going by the explanation in the second post, the value stored inside the variable sz as returned from cal_size() should be a compile time constant.

所涉及的方法，即cal_Size()和DoSomething()本身就是函数模板，因此按照第二篇文章中的解释，存储在变量sz中的值应该是一个编译时间常数，该值是从cal_Size()返回的。

So why is it that I am still getting this error?

那么，为什么我仍然收到这个错误呢？

TIA

Tia