在同一个类模板中存储常量或非常量引用
是指在一个类模板中定义一个成员变量，该成员变量可以存储常量或非常量引用。
常量引用是指在声明引用时使用const关键字修饰，表示引用的值不可修改。非常量引用则没有使用const修饰，可以修改引用的值。
在同一个类模板中存储常量或非常量引用的优势是可以方便地在类内部使用这些引用或常量，并且可以避免在多个成员函数中重复定义相同的引用或常量。
应用场景：
- 在类模板中存储常量引用可以用于传递不可修改的参数，以提高效率和避免不必要的拷贝。
- 在类模板中存储非常量引用可以用于传递可修改的参数，并且修改后的值可以在类内部的其他成员函数中被访问和使用。
推荐的腾讯云相关产品和产品介绍链接地址： 腾讯云提供了丰富的云计算产品和服务，以下是一些相关产品和介绍链接地址：
- 云服务器（CVM）：提供弹性计算能力，支持多种操作系统和应用场景。详情请参考：https://cloud.tencent.com/product/cvm
- 云数据库 MySQL 版（CDB）：提供高性能、可扩展的关系型数据库服务。详情请参考：https://cloud.tencent.com/product/cdb_mysql
- 云存储（COS）：提供安全可靠的对象存储服务，适用于各种数据存储和传输场景。详情请参考：https://cloud.tencent.com/product/cos
- 人工智能平台（AI Lab）：提供丰富的人工智能算法和模型，支持图像识别、语音识别、自然语言处理等应用。详情请参考：https://cloud.tencent.com/product/ailab
- 物联网（IoT Hub）：提供物联网设备接入和管理的平台，支持海量设备连接和数据处理。详情请参考：https://cloud.tencent.com/product/iothub
- 区块链服务（Tencent Blockchain）：提供安全可信的区块链解决方案，支持企业级应用场景。详情请参考：https://cloud.tencent.com/product/tencentblockchain
请注意，以上链接仅供参考，具体产品和服务详情请以腾讯云官方网站为准。
相关·内容
1回答
不久前，我了解到您可以将文字传递到如下模板中：
template <int x>
class myClass { };
//Later
myClass<12> var;
现在我已经定义了我自己的int类型，并且希望用that....but来做同样的事情，结果是令人头痛的。
我正试着像这样achieve....something：
class myIntType;
template <myIntType val>
class Other{
};
不幸的是，这是非法的：
因此，另一次尝试不是提供一个实际实例，而是传递一个将返回实例的函数(因为这是一个整数类型
浏览 1提问于2016-06-01得票数 2
2回答
我从许多其他堆栈溢出线程(如)中了解到，模板参数是在编译时计算的。此外，非类型模板参数应该是一个常量表达式、积分表达式或指向具有外部链接的对象的指针。
而且，我在Makefile中的g++命令中没有使用--std=c++0x。
那么，是否可以实例化作为参数传递为NULL的模板类？
// I have a template class like this -
template<class T, T invalidVal, int e> class A
{
static inline bool dummy(T value)
{
return 0;
浏览 4提问于2012-09-28得票数 3
回答已采纳
#include <iostream>
using namespace std;
template<const int arr[]>
struct S {
static constexpr int value = arr[0];
};
constexpr int arr[] = { 5 };
int main() {
cout << S<arr>::value << endl;
}
该程序使用gcc 5.1及更高版本编译并打印5，但MSVC 19.10.25019出现以下错误：
错误C2975：'S&
浏览 7提问于2017-04-20得票数 4
回答已采纳
我要做的是创建一个模板函数，它存储了一个泛型函数指针和关于如何转换为它的实际类型的信息。我的脚本绑定应用程序接口正在使用它从Python为游戏引擎进行C++函数调用。在使用XCode4和LLVM将其移植到OSX的过程中，我遇到了一个错误。这个示例代码在Visual Studio 2012中编译和运行得很好，但在LLVM中出现错误“没有匹配的函数来调用”call to‘Call’。
#include <iostream>
void testfun (int i)
{
std::cout << "Hello World " << i <
浏览 2提问于2013-04-15得票数 3
回答已采纳
2回答
模板指针参数包
、、、
为什么带有指针模板参数包的模板函数不能用相同指针的偏移量实例化？
我的意思是:考虑到这段简短的代码，为什么我必须注释掉最后两行？
template <int * ... pt> void f() {}
int n[] = {1, 2, 3};
int m = n[1];
int main()
{
f<n>(); // this is accepted
f<n, &m>(); // this is accepted too
//f<n, n+1>(); // this is not.
//f<n
浏览 3提问于2018-02-13得票数 6
为什么这是可行的？
char __nontype[] = "foo";
typedef TemplateClass<T, __nontype> MyClass;
但是这个(使用常量变量)不是吗？
const char __nontype[] = "foo";
typedef TemplateClass<T, __nontype> MyClass;
编译器错误：
错误：‘__nontype’不能出现在常量表达式中
错误:模板参数2无效
浏览 3提问于2012-02-08得票数 8
回答已采纳
1回答
考虑如下
struct dummy{};
dummy d1;
dummy d2;
template<dummy* dum>
void foo()
{
if (dum == &d1)
; // do something
else if (dum == &d2)
; // do something else
}
现在，可以这样调用foo
foo<&d1>();
foo<&d2>();
一切都如期而至。但以下并不是
constexpr dummy* dum_ptr = &d
浏览 4提问于2016-12-11得票数 14
回答已采纳
1回答
为什么下面的代码是错误的？模板接受哪种类型的参数？
class MyClass
{
int var;
};
template <MyClass a> struct s
{
};
int main()
{
MyClass var;
struct s<var>;
return 0;
}
浏览 0提问于2013-03-02得票数 0
回答已采纳
3回答
我正在使用STM32的硬件定时器来连接许多光学编码器。我想创建一个模板化的类，它为与硬件计时器交互提供了一个方便的接口。定时器寄存器是内存映射寄存器，其地址在制造商提供的与器件数据手册匹配的报头中定义。模板参数实际上将是定时器外围设备的基址。下面是我目前正在尝试做的一个最小的工作示例：
#include <cstdint>
// Effectively supplied by chip manufacturer headers
struct timer_peripheral {
volatile uint32_t count;
// ... lots of other r
浏览 0提问于2013-05-16得票数 3
1回答
请考虑以下代码：
using func = int (*)(int, int);
template<func F>
void do_something(int first, int second) {}
int something(int first, int second) { return 42; }
void f()
{
constexpr auto function = something;
do_something<function>(10, 20);
}
它是用C++17标准兼容编译器编译和运行的，但是C++11标准失败了：
error:
浏览 1提问于2020-11-30得票数 12
回答已采纳
1回答
正如标准模板中所写的，非类型模板参数之一可以是指向对象的指针。对于其他人：
template <int* x>
void f()
{}
但是，在实例化期间给出参数时，只允许指向具有外部链接的对象的指针。为什么？为什么标准不允许用指针实例化带有内部链接的对象的非类型模板？
我在StackOverflow的其他主题中找到了一些解释，但对我来说还不清楚：
模板参数列表中提供的非类型模板参数是一个表达式，其值可以在编译时确定。这些参数必须是:常量表达式、函数或具有外部链接的对象的地址，或静态类成员的地址。
所以，如果我在全局范围内有static const int x = 10;，
浏览 2提问于2014-12-10得票数 3
回答已采纳
我一直在试验C++中的函数类型。注意，我指的不是像这样的指向函数的指针类型：
typedef void (*voidFuncPtr)();
但更具异国情调：
typedef void (voidFunc)();
我没想到下面的代码会被编译，但令人惊讶的是，它做到了：
template<voidFunc func>
class funcClass
{
public:
void call() { func(); };
};
void func()
{ }
void Test()
{
funcClass<func> foobar;
foobar.c
浏览 1提问于2012-10-20得票数 4
回答已采纳
1回答
不要问我为什么，但我试图在编译时初始化一个指针数组(指针指向另一个静态数组的元素)。这涉及到TMP，因此，模板递归，同时构建一个可变的列表。我把问题缩小到以下几个方面：
template <int const * const P>
struct Foo
{
constexpr static int const * const bar = P;
};
constexpr int const array[5] = {0, 1, 2, 3, 4}; // global, so has linkage
int main()
{
/* 1 */ cout <<
浏览 2提问于2014-10-27得票数 2
回答已采纳
下面的代码是在旧版gcc上编译的，而不是在版本6(使用-std=c++1z)上编译的。Clang也拒绝它，说物体val没有正确的链接。我不明白有什么区别。指针类型的constexpr变量不应该多少透明地工作吗？在语法中，是否有什么东西可以让它起作用呢？或者这是否违反了标准的某些部分？
typedef void(*t_voidfn)();
template <t_voidfn> struct s {};
void fn() {
static constexpr t_voidfn val = &fn;
s<val> x;
}
另一方面，这个可以工作。
typ
浏览 6提问于2016-09-11得票数 12
回答已采纳
3回答
我有以下代码：
template<int k>
void foo()
{
}
int main(int argc, char* argv[])
{
int k = 1000;
foo<k>();
return 0;
}
它不会编译，但如果我将k声明为const，它就会编译：
template<int k>
void foo()
{
}
int main(int argc, char* argv[])
{
const int k = 1000;
foo<k>();
return 0;
}
现在，我明白
浏览 2提问于2011-11-23得票数 5
回答已采纳
1回答
为什么作为非类型参数传递的参数应该是全局的而不是局部的？不是只在编译时创建和分配内存吗？
在这种情况下，p是一个常量指针，所以它不能指向任何其他变量，那么它也给出了error.Why？
template<int* ptr>
class A{};
int x;
int *const p = &x;
int main() {
x = 9;
A<&x> ob;
A<p> ob2;//giving error
cin.get();
}
另外，为什么只允许整型作为非类型参数，而不允许使用char或float？
浏览 3提问于2013-05-23得票数 4
回答已采纳
2回答
为什么使用局部变量作为非类型参数是非法的？
例如，在下一段代码中，local_var不能作为X的参数。
template<int& x> struct X {};
void f(int local_var)
{
X<local_var> x;
}
浏览 0提问于2013-06-28得票数 6
回答已采纳
我非常清楚，直接将const char*作为模板非类型参数传递是错误的，因为在两个不同的翻译单元中定义的两个相同的字符串文本可能有不同的地址(尽管大多数情况下编译器使用相同的地址)。有一个技巧可以使用，请参阅下面的代码：
#include <iostream>
template<const char* msg>
void display()
{
std::cout << msg << std::endl;
}
// need to have external linkage
// so that there are no multi
浏览 4提问于2015-06-02得票数 25
回答已采纳
1回答
考虑下面的类S，它包含一个函数指针，以及该类的constexpr对象s，该类是用lambda初始化的：
struct S
{
void (*f) ();
};
constexpr S s { []{} };
现在，如果我用S类型的非类型模板参数编写一个模板S，并在s上实例化它，如下所示：
template<S> struct X {};
using x = X<s>;
clang编译代码，但是gcc抱怨说：
error: '<lambda()>::_FUN' is not a valid template argument o
浏览 4提问于2020-11-03得票数 6
回答已采纳
2回答
非类型参考参数/参数
、、、、
为什么非类型引用的模板参数不能是另一个引用(g++ 4.8.1)：
template <int& N> void test() { }
int x = 5;
int& p = x;
int main(){
test<x>(); //compiles fine
test<p>(); //error: could not convert template argument 'p' to 'int&'|
}
我看不出标准p在哪里违反了什么，这似乎是最相关的部分(N3337)：
14.
浏览 5提问于2015-10-23得票数 4
回答已采纳
2回答
我在问自己下面的代码为什么工作，以及说明符extern在实例化baz_instance时做什么
struct baz {
int value;
};
extern const baz baz_instance = {3};
template<baz const& b>
int foo(){
return b.value;
}
int main(){
foo<baz_instance>();
return 1;
}
为什么上面的代码首先要编译，如果忽略了extern说明符，为什么不再编译呢？在本例中，extern说明符是做什么
浏览 0提问于2015-06-23得票数 10
回答已采纳
我看到以下类型被允许作为非类型模板参数：
积分类型
枚举
对对象/方法的ptr
对对象/方法的值引用
std::nullptr_t
我不明白一个非常量指针或一个lvalue引用是如何被接受的？它们不应该是常量类型，以便在编译时识别它们吗？
显然，我并不比标准更聪明，所以有人能给我举一个lvalue引用的例子，或者一个指针被用作非模板参数吗？
浏览 4提问于2014-09-30得票数 4
回答已采纳
2回答
我正在阅读的这本书经常提到，类型必须是文字类型才能在某些情况下使用，例如可以使用常量表达式的类型。但给出的唯一定义是文字类型是算术、引用或指针类型。但是当我们定义一个constexpr类型时，它似乎必须用一个文本或一个变量初始化，这个变量最初是用一个文本初始化的。
我搞不清什么是文字类型，什么不是。
浏览 0提问于2013-09-03得票数 24
回答已采纳
据我所知，模板值需要在编译时知道。所以我写了一个小例子，看看我得到了它，但很明显我没有。所以我得到了这个：
`defValue' cannot appear in a constant-
expression
谁能告诉我这个问题是什么，以及如何解决它？
#include <iostream>
template <class T,T defaultVal, int dim=255>
class Vec
{
T _vec[dim];
int _dim;
public:
Vec () : _dim(dim)
{
浏览 2提问于2010-10-02得票数 3
回答已采纳
3回答
我在windows上遇到了"error C2327“。
我减少了我的代码，在测试程序中得到了类似的错误
#include <boost/intrusive/list.hpp>
#include <iostream>
class Test {
protected:
typedef Test self_type;
boost::intrusive::list_member_hook<> order_hook;
public:
typedef boost::intrusive::member_hook
浏览 0提问于2013-10-24得票数 5
下面的代码是我试图为客户需求实现的一个功能的简化的最小版本。
它无法在IBM编译器(version 9和version 11 )上编译，并出现错误A non-type template parameter cannot have type "int X::*".。然而，我已经在g++ 4.7.2，clang++ 3.2和Intel13.0上尝试了相同的代码，他们成功地编译了它。
我很想知道XLC是这里唯一明智的声音，还是其他编译器是正确的？
struct X {
X() : y(123) {}
int y;
};
struct XFoo {
typede
浏览 1提问于2013-02-05得票数 0
回答已采纳
1回答
在回答时，我使用gcc ()和clang ()尝试了以下代码：
typedef long (*func)(int);
long function(int) { return 42; }
struct Test
{
static constexpr func f = &function;
};
template<func c>
struct Call
{
static void f()
{
c(0);
}
};
int main()
{
Call<Test::f>::f();
}
我不确定哪个编译器是
浏览 2提问于2013-04-07得票数 9
回答已采纳
3回答
非类型(参考)模板参数和链接
、、、、
在以下内容中，
int i{3};
const int j{3};
extern const int k{3};
template <typename T, T&>
void f() {}
int main()
{
f<int, i>(); // OK
f<int const, j>(); // not valid template argument: 'j' has not external linkage
f<int const, k>(); // OK
}
GCC给出了使
浏览 6提问于2014-05-05得票数 2
回答已采纳
1回答
请考虑以下代码：
int x = 0;
template<int& I>
struct SR {};
template<int* I>
struct SP {};
SR<(x)> sr;
SP<&(x)> sp;
int main(void)
{
}
clang++ 3.8.0抱怨：
main.cpp:10:5: error: non-type template argument does not refer to any declaration
SP<&(x)> sp;
^~~
main.cp
浏览 3提问于2016-09-29得票数 7
回答已采纳
3回答
我试图了解如何将类文件加载到方法区域并执行。我对这个恒定的游泳池感到非常困惑。
在最初创建常量池时？编译类文件或加载类时。
字节码是如何在方法区域组织的，方法表是由什么组成的？
有谁能在方法区域内显示草图映射的图片表示，以便清楚地理解？
浏览 4提问于2017-12-15得票数 0
回答已采纳
3回答
假设我们有一个模板函数，它的非类型参数为const char *，如下所示：
template <const char * MESSAGE> void print() {
std::cout << MESSAGE << '\n';
}
使用此模板不会成为问题，因为在编译时可以推断出MESSAGE，因此以下使用是合法的：
namespace {
char namespace_message[] = "Anonymous Namespace Message";
constexpr char namespac
浏览 4提问于2015-03-02得票数 23
回答已采纳
3回答
以下程序编译：
template <const int * P>
class Test{};
extern const int var = 42; //extern needed to force external linkage
int main()
{
Test<&var> test;
}
然而，这一次却没有，这对我来说是个惊喜：
template <const int * P>
class Test{};
extern const int var = 42; //extern needed to force external li
浏览 3提问于2011-09-12得票数 33
回答已采纳
1回答
你能使用一个常数变量的地址吗？
、、、、
我有一个变量，其地址作为第四个参数传递给。注意，此参数被声明为常量指针(const void *optval)。
在我提出供检查的修补程序中，我将该变量的声明更改为静态参数。一位评论这一变化的人对此表示担忧:他认为，你是否总能得到一位警官的地址，这是值得怀疑的。他建议我来做康斯特。在谷歌搜索后，我找不到很多关于constexpr变量的地址和对它的关注。有人能解释一下，关于一个参数的地址的保证是什么吗?如果有的话，关于使用它的注意事项是什么？
如果有用的话，下面是代码(我添加了static constexpr，它以前只是一个int )：
static constexpr int ONE = 1;
浏览 3提问于2020-03-10得票数 4
回答已采纳
在C++中，如果我定义了一个复制构造函数和operator=来引用该类的非常量，编译器是否应该仍然提供常量引用的默认版本？
struct Test {
Test(Test &rhs);
Test &operator=(Test &rhs);
private:
// Do I still need to declare these to avoid automatic definitions?
Test(const Test &rhs);
Test &operator=(const Test &rhs);
};
浏览 5提问于2012-08-13得票数 7
回答已采纳
我想从函数指针数组中传递一个函数指针作为模板参数。我的代码似乎使用MSVC编译，尽管Intellisense抱怨说出了问题。gcc和clang都没有编译代码。
请考虑以下示例：
static void test() {}
using FunctionPointer = void(*)();
static constexpr FunctionPointer functions[] = { test };
template <FunctionPointer function>
static void wrapper_function()
{
function();
}
浏览 2提问于2020-01-17得票数 10
回答已采纳
我刚开始学斯威夫特，发现了一些我不懂的东西。在教程中，作者在常量中创建了一个NSMutableAttributedString。后来那个常数被改变了。我不明白的是，这是怎么可能的，没有任何错误。由于缺少更好的术语，NSMutableAttributedString是否以某种方式凌驾于常数的规则之上？
@IBAction func buttonPressed(sender: UIButton) {
let title = sender.titleForState(.Normal)!
let plainText = "\(title) button pressed"
浏览 2提问于2015-02-22得票数 1
回答已采纳
请考虑以下类
template<class T>
class foo
{
public:
auto bar() { return m_t.bar(); }
private:
T m_t;
};
如果我们希望foo<T>::bar在T::bar为非抛出时为非抛出，我们可以将其声明更改为
auto bar() noexcept(noexcept(m_t.bar())) { return m_t.bar(); }
但是，如果我们希望在每次使用constexpr指定T::bar时都使用constexpr指定foo<T>::bar，我们该怎么办
我们
浏览 0提问于2016-04-05得票数 4
1回答
限定友函数模板实例化
、、、
今天早上看到/时，我遇到了一个我无法理解的部分(12.5.2如果你有这本书的话)。在此略去一些看似无关的内容：
如果“朋友”声明中的名称后面没有尖括号，则有两种可能性
如果名字不合格..。
如果名称是限定的(它包含::)，则该名称必须引用以前声明的函数或函数模板。匹配函数优于匹配函数模板。然而，这样的朋友声明不能成为一个定义。
使用以下代码
void multiply(void*);
template <typename T>
void multiply(T);
class Comrades {
// ... skipping some frie
浏览 0提问于2019-01-05得票数 1
回答已采纳
2回答
模板实例化问题
、、、
我使用包含模板声明的库文件Slist.h，在mypgm.c(cpp文件)的构造器中实例化definition.The库文件，.The编译器抛出一个在底部提到的错误。
Slist.h
template <class Object>
class SList; // fwd declaration.
template <class Object>
class SListItr; // fwd declaration.
template <class Object>
class SListNode
{
SListNode( const Object
浏览 6提问于2013-02-08得票数 0
2回答
这件事发生在很多人身上，也发生在我身上。在C++中，我一直在玩编译时字符串。
我决定采取一种显然无法使用的方法:使用template <char...>类。
这就是我想出来的，它很普通，没什么特别的，也不管用。
template <char... chars> class string
{
public:
static constexpr const char value[] = {chars...};
constexpr string()
{
}
constexpr operator decltype(value) &am
浏览 4提问于2016-07-03得票数 9
回答已采纳
3回答
我真的不明白为什么下面的代码不编译：
template<const char*>
struct Foo{};
constexpr const char s1[] = "test1";
constexpr const char* const s2 = "test2";
int main()
{
Foo<s1> foo1; // ok
// Foo<s2> foo2; // doesn't compile
}
取消注释main()中的最后一行使g++和clang++发出错误
错误：'s2‘不是
浏览 2提问于2015-03-12得票数 19
回答已采纳
2回答
我正在用C++编写一个玩具正则表达式引擎作为学习练习，我遇到了一个编译器错误。下面是实现不同表达式子类型的类的定义：
// ***************************************************************
// ***************************************************************
class RegexExpression {
public:
virtual RegexResult match(std::string);
};
// ****************
浏览 4提问于2013-09-12得票数 1
2回答
字符串池与常量池
、、、
让我们看一看折叠代码片段：
String s1 = "Hello";
String s2 = "Hello";
由于实习，这两个变量都指向同一个对象。由于字符串是不可变的，因此只创建了一个对象，并且都引用了同一个对象。
constant pool也是一种东西，它包含所有常量(整数、字符串等)。在类中声明的。这是每个班级的具体情况。
System.out.println("Hello"); // I believe this Hello is different from above.
问题：
string pool是指常量池中的
浏览 1提问于2014-04-23得票数 23
回答已采纳
我尝试了下面的代码。
template <int VAL>
void printVAL()
{
for(int i=0;i<VAL; i++){
cout << " i value is "<<i<<endl;
}
}
实例化: printVAL<100>()
当我使用(std::string s )作为非类型模板参数时，编译器向我发出了以下错误：
"class std::basic_str<char>' is not a valid type for
浏览 3提问于2013-04-25得票数 1
回答已采纳
1回答
c++模板继承方案
、、、
我想知道我编码的方式是否正确。我可以创建一个从模板类继承的模板类吗？如果可以，下面的代码是否正确：
template<typename Type>
class A{
public:
A(){};
method_A(){//do whatever}
protected:
int a;
}
第二个类是：
template<typename Type>
class B:public<Type> A {
public:
B(){};
method_B(){this
浏览 0提问于2013-07-21得票数 2
回答已采纳
2回答
使用变量实例化模板函数
、、、
我在一个类中有三个指针，每个指针都是模板结构的实例化。我试图使用返回类型相应不同的get<>()方法检索它们中的任何一个。
//Example program
#include <iostream>
#include <map>
#include <string>
#include <boost/shared_ptr.hpp>
#include <boost/variant.hpp>
#include <boost/any.hpp>
class CBase {};
enum en {Aa = 1, Bb = 2
浏览 3提问于2016-05-19得票数 0
回答已采纳
我在我的c#应用程序中创建了一种数据驱动的方法来创建UI元素，允许我在运行时调试非引用类型变量(bools、ints等)以进行调试。由于不能在c#中存储引用(就像在C++中传递指针一样)，正如在中解释的那样，我必须创建委托才能获得和设置我希望以这样方式调试的任何变量：
createCheckboxSetting("Debug Bool",
delegate(bool newVal) { testBool = newVal; },
delegate() { return testBool; }
浏览 5提问于2013-06-05得票数 0
3回答
我有一个Java EE项目，在这个项目中，我有很多对接收字符串的函数的调用，这个字符串存储在一个常量中，这个常量不一定是在同一个文件中定义的，有时它是在单独的常量类中定义的。我需要遍历项目中的所有类，并检索这些常量的值。做这件事的聪明方法是什么？我考虑过使用反射并加载项目中的每个类(几百个)，但我不确定这是不是最好的方法。
提前谢谢。
浏览 0提问于2012-09-03得票数 0
想象一下写一些类似的东西
class any {
public:
any();
any(const any &);
any(any &&);
template<typename ValueType> any(const ValueType &);
template<typename ValueType> any(ValueType &&);
是否会为任何可能的any调用适当的(复制/移动)构造函数？还是必须用SFINAE编写，例如：
template<typename ValueType,
t
浏览 3提问于2014-09-14得票数 4
回答已采纳
1回答
我试图弄清楚名称空间在PHP中是如何工作的，但是很难理解什么时候需要全局名称空间前缀。以下列例子为例：
index.php
namespace MySpace;
require_once 'file.php';
Test::hello();
hi();
file.php
class Test {
public static function hello () {
echo 'hello';
}
}
function hi() {
echo 'hi';
}
这是行不通的，但是编写\Test::hell
浏览 3提问于2014-04-10得票数 1
回答已采纳
扫码
添加站长 进交流群
领取专属 10元无门槛券
手把手带您无忧上云
相关资讯
热门标签
云服务器
ICP备案
对象存储
即时通信 IM
实时音视频活动推荐
腾讯云开发者
