#static
static void main 的静态方法里log.info方法不打印日志,这个怎么解决？
synchronized static 为什么不起作用?
什么时候使用PHP的static属性？
在PHP中，static属性用于声明类的静态成员。静态成员是类的所有实例共享的，而不是仅限于某个特定实例。静态属性在内存中只有一个副本，它们不依赖于类的实例。以下是使用PHP static属性的适当情况：
1. 当你需要在类的所有实例之间共享数据时。例如，如果你有一个计数器，用于跟踪类的实例数量，这个计数器应该是静态的，因为它需要在所有实例之间共享。
```php
class MyClass {
public static $instanceCount = 0;
public function __construct() {
self::$instanceCount++;
}
}
$obj1 = new MyClass();
$obj2 = new MyClass();
echo MyClass::$instanceCount; // 输出 2，因为有两个实例
```
2. 当你需要在不创建类实例的情况下访问类的方法或属性时。例如，你可以使用静态方法作为工具函数，而不需要实例化类。
```php
class Utility {
public static function formatDate($date) {
return date('Y-m-d', strtotime($date));
}
}
echo Utility::formatDate('2022-01-01'); // 输出 "2022-01-01"，无需创建Utility类的实例
```
3. 当你需要限制类的实例化以确保只有一个实例存在时。这种设计模式称为单例模式。在这种情况下，你可以使用静态属性来存储唯一实例。
```php
class Singleton {
private static $instance = null;
private function __construct() { } // 私有构造函数，防止外部实例化
public static function getInstance() {
if (self::$instance === null) {
self::$instance = new Singleton();
}
return self::$instance;
}
}
$instance1 = Singleton::getInstance();
$instance2 = Singleton::getInstance();
var_dump($instance1 === $instance2); // 输出 true，因为它们是同一个实例
```
在使用静态属性时，请注意它们的使用场景和限制。静态成员不能访问类的非静态成员，因为非静态成员需要类的实例。此外，静态成员在类的继承中可能导致意外的行为，因为它们不遵循常规的继承规则。在这些情况下，考虑使用其他方法，如依赖注入或工厂模式。
腾讯云提供了强大的云服务器、云数据库、云存储等产品，帮助开发者轻松构建和部署应用。如果你在使用PHP开发Web应用程序，可以考虑使用腾讯云的云服务器产品，它提供了灵活的配置选项和丰富的操作系统支持，包括PHP环境。通过使用腾讯云，你可以专注于开发应用程序，而不用担心底层基础设施的管理和维护。... 展开详请
PHP单例模式为什么还能为static常量赋值
PHP单例模式是一种设计模式，用于确保一个类只有一个实例，并提供一个全局访问点
在PHP中，单例模式的实现通常使用`static`关键字。`static`关键字可以用于声明静态属性和静态方法。静态属性属于类本身，而不是类的实例。这意味着，静态属性在类的所有实例之间共享，可以在不创建类实例的情况下访问。
让我们通过一个例子来说明这一点。假设我们有一个名为`Singleton`的类，它使用单例模式。我们可以使用`static`关键字声明一个静态属性`$instance`，用于存储类的唯一实例。同时，我们可以使用`static`关键字声明一个静态方法`getInstance()`，用于获取类的唯一实例。
```php
class Singleton {
private static $instance = null;
private function __construct() {
// 私有构造函数，防止外部实例化
}
public static function getInstance() {
if (self::$instance === null) {
self::$instance = new Singleton();
}
return self::$instance;
}
}
```
在这个例子中，我们可以看到`$instance`是一个静态属性，它在类的所有实例之间共享。当我们调用`Singleton::getInstance()`方法时，它会检查`$instance`是否为`null`。如果是，它会创建一个新的`Singleton`实例并将其赋值给`$instance`。否则，它会返回现有的`$instance`。
这样，我们可以确保`Singleton`类只有一个实例，并通过`Singleton::getInstance()`方法全局访问它。同时，我们可以为静态属性`$instance`赋值，以便在类的所有实例之间共享。
需要注意的是，虽然PHP单例模式可以为静态属性赋值，但这并不意味着它是最佳实践。在实际应用中，单例模式可能会导致代码难以测试和维护。在许多情况下，依赖注入和其他设计模式可能是更好的选择。
此外，如果您需要在云计算行业中查找相关产品，腾讯云提供了一系列优秀的服务，如云服务器、云数据库、云存储等。这些服务可以帮助您轻松构建和部署应用程序，同时确保高可用性和可扩展性。如果您需要了解更多关于腾讯云的信息，请随时提问。... 展开详请
php的static静态方法怎么使用
在PHP中，使用static关键字可以创建静态方法。静态方法是属于类的方法，而不是属于类的实例。这意味着，您可以在不创建类的实例的情况下调用静态方法。静态方法对于实用工具类或单例模式非常有用。
以下是如何在PHP中使用静态方法的示例：
1. 定义一个包含静态方法的类：
```php
class MyClass {
public static function myStaticMethod() {
echo "这是一个静态方法。";
}
}
```
2. 调用静态方法：
要调用静态方法，您可以使用双冒号(::)操作符，如下所示：
```php
MyClass::myStaticMethod(); // 输出：这是一个静态方法。
```
注意：静态方法不能访问类的非静态属性和非静态方法，因为它们不依赖于类的实例。
在腾讯云上，您可以使用静态方法实现腾讯云API的调用。例如，腾讯云提供了一个名为`TencentCloud\Common\Credential`的类，用于管理腾讯云API的凭据。您可以使用静态方法创建一个`Credential`实例，如下所示：
```php
use TencentCloud\Common\Credential;
$secretId = "your_secret_id";
$secretKey = "your_secret_key";
$cred = Credential::getInstance($secretId, $secretKey);
```
在这个例子中，我们使用`getInstance`静态方法创建了一个`Credential`实例。这样，我们就可以在不创建`Credential`类实例的情况下调用腾讯云API。... 展开详请
php static::KEY 和 self::KEY 区别是什么？
在 PHP 中，`static::KEY` 和 `self::KEY` 都用于访问类的静态属性，但它们之间有一些区别。
1. `self::KEY`：使用 `self` 关键字访问当前类的静态属性。当你在类的方法中使用 `self::KEY` 时，它将始终引用当前类的属性，而不考虑继承或覆盖。
例如：
```php
class A {
const KEY = 'A_KEY';
public function getKey() {
return self::KEY;
}
}
class B extends A {
const KEY = 'B_KEY';
}
$b = new B();
echo $b->getKey(); // 输出 'A_KEY'
```
2. `static::KEY`：使用 `static` 关键字访问当前类的静态属性。当你在类的方法中使用 `static::KEY` 时，它将引用调用该方法的类的属性。这意味着，如果子类覆盖了该属性，`static::KEY` 将返回子类的属性值。
例如：
```php
class A {
const KEY = 'A_KEY';
public function getKey() {
return static::KEY;
}
}
class B extends A {
const KEY = 'B_KEY';
}
$b = new B();
echo $b->getKey(); // 输出 'B_KEY'
```
总结：`self::KEY` 总是引用当前类的属性，而 `static::KEY` 会根据调用方法的类的属性进行调整。在腾讯云产品中，您可以使用腾讯云云服务器（CVM）、云数据库（TDSQL）等产品来部署和托管您的 PHP 应用程序。这些产品提供了高性能、可扩展的基础设施，帮助您快速构建和部署应用程序。... 展开详请
PHP new static() 是什么意思？
`PHP new static()` 是一种在 PHP 中实现工厂方法模式的方法。在这种模式中，我们使用一个静态方法创建并返回一个新的类实例。`new static()` 的意义在于它允许我们在子类中使用父类的静态方法创建子类的实例，而不是父类的实例。这样可以实现多态性。
举个例子，假设我们有一个基类 `Animal` 和两个子类 `Dog` 和 `Cat`。我们希望在 `Animal` 类中实现一个静态方法 `create`，用于创建并返回 `Dog` 或 `Cat` 的实例。
```php
class Animal {
public static function create($type) {
if ($type == 'dog') {
return new Dog();
} elseif ($type == 'cat') {
return new Cat();
}
}
}
class Dog extends Animal {
public function bark() {
echo "Woof!";
}
}
class Cat extends Animal {
public function meow() {
echo "Meow!";
}
}
```
在这个例子中，我们使用 `new static()` 替换 `new Dog()` 和 `new Cat()`：
```php
class Animal {
public static function create($type) {
if ($type == 'dog') {
return new static();
} elseif ($type == 'cat') {
return new static();
}
}
}
class Dog extends Animal {
public function bark() {
echo "Woof!";
}
}
class Cat extends Animal {
public function meow() {
echo "Meow!";
}
}
```
现在，当我们调用 `Dog::create('dog')` 时，它将返回一个 `Dog` 实例；当我们调用 `Cat::create('cat')` 时，它将返回一个 `Cat` 实例。这样，我们可以在子类中重用父类的静态方法，同时保持多态性。
在腾讯云相关产品中，我们可以使用腾讯云云服务器（CVM）、云数据库（TencentDB）等产品来部署和托管 PHP 应用程序。这些产品提供了高性能、高可用性和可扩展性的基础设施，帮助您轻松构建和运行 PHP 应用程序。... 展开详请
php static方法指的是什么
PHP中的static方法指的是静态方法。静态方法是属于类的方法，而不是属于类的实例（对象）。这意味着，您可以在不创建类的实例的情况下调用静态方法。静态方法使用关键字“static”进行声明，并且可以直接通过类名调用，而不需要实例化类。
以下是一个简单的例子：
```php
class MyClass {
public static function myStaticMethod() {
echo "This is a static method.";
}
}
// 调用静态方法，无需实例化类
MyClass::myStaticMethod(); // 输出 "This is a static method."
```
在这个例子中，我们定义了一个名为`MyClass`的类，其中包含一个名为`myStaticMethod`的静态方法。我们可以直接通过类名`MyClass`调用这个静态方法，而不需要创建`MyClass`的实例。
需要注意的是，静态方法不能访问类的非静态属性和非静态方法，因为它们不依赖于类的实例。静态方法通常用于执行与类相关但不依赖于类实例的任务，例如工具函数或数学计算。
腾讯云提供了强大的云计算服务，如云服务器（CVM）、云数据库（TencentDB）等。这些服务可以帮助您轻松构建和部署PHP应用程序，同时提供高性能、可扩展性和安全性。如果您需要在腾讯云上部署PHP应用程序，可以考虑使用云服务器（CVM）和云数据库（TencentDB）等产品。... 展开详请
Springboot如何读取自定义pro文件注入static静态变量
答案：
要在Spring Boot中读取自定义的`.properties`文件并将其注入到静态变量中，您可以按照以下步骤操作：
1. 在`src/main/resources`目录下创建自定义的`.properties`文件，例如`custom.properties`。
2. 在`custom.properties`文件中添加您需要的配置属性，例如：
```
app.custom.property=value
```
3. 创建一个配置类，使用`@Configuration`和`@PropertySource`注解来加载自定义的`.properties`文件。然后使用`@Value`注解将属性值注入到静态变量中。示例如下：
```java
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.PropertySource;
@Configuration
@PropertySource("classpath:custom.properties")
public class CustomConfig {
public static String CUSTOM_PROPERTY;
@Value("${app.custom.property}")
public void setCustomProperty(String customProperty) {
CUSTOM_PROPERTY = customProperty;
}
}
```
4. 在需要使用这些静态变量的地方，直接使用`CustomConfig.CUSTOM_PROPERTY`即可。
这样，您就可以在Spring Boot应用中读取自定义的`.properties`文件并将其注入到静态变量中了。
需要注意的是，这种方法仅适用于Spring Boot应用。如果您需要在其他类型的应用程序中实现类似的功能，可以考虑使用其他配置管理库，例如Apache Commons Configuration或者使用Java原生的`Properties`类来加载和读取配置文件。
此外，如果您需要在云计算环境中使用类似的功能，可以考虑使用腾讯云的云服务器产品，它提供了灵活的配置管理和弹性扩展能力，可以帮助您快速构建和部署应用程序。腾讯云云服务器产品提供了丰富的API和SDK，可以方便地与您的应用程序集成，实现自动化管理和运维。同时，腾讯云云服务器还提供了安全、可靠的基础设施服务，确保您的应用程序在云端稳定运行。... 展开详请
怎么让Spring Boot中 static 和 templates 下的文件不能被直接访问到
要阻止对Spring Boot中static和templates文件夹下的文件的直接访问，您可以通过以下方法实现：
1. 在`application.properties`或`application.yml`文件中，添加以下配置：
```
spring.resources.add-mappings=false
```
这将禁用静态资源的自动映射，从而阻止对static和templates文件夹下的文件的直接访问。
2. 创建一个自定义的WebMvcConfigurer，以便在其中配置静态资源的访问权限。在您的Spring Boot项目中，创建一个新的Java类，如下所示：
```java
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.ResourceHandlerRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
@Configuration
public class CustomWebMvcConfigurer implements WebMvcConfigurer {
@Override
public void addResourceHandlers(ResourceHandlerRegistry registry) {
registry.addResourceHandler("/**")
.addResourceLocations("classpath:/static/")
.resourceChain(true);
}
}
```
这将配置静态资源的访问权限，使得只有通过控制器暴露的资源才能被访问。
3. 在您的控制器中，使用`@RequestMapping`或`@GetMapping`注解创建一个新的映射，以便允许访问static和templates文件夹下的文件。例如：
```java
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
@Controller
@RequestMapping("/files")
public class FileController {
@GetMapping("/{filename}")
public String getFile(@PathVariable String filename) {
return "forward:/" + filename;
}
}
```
这将允许通过`/files/{filename}`访问static和templates文件夹下的文件。
通过这些步骤，您可以阻止对Spring Boot中static和templates文件夹下的文件的直接访问，并通过控制器来控制访问权限。... 展开详请
为什么spring boot工程添加了拦截器之后，静态资源static目录不会自动映射url？
在Spring Boot工程中，添加拦截器后，静态资源（static目录）不会自动映射URL的原因可能是拦截器的配置覆盖了默认的静态资源处理。Spring Boot默认会映射/static/**路径到静态资源目录，但如果拦截器中有类似的映射配置，它可能会覆盖默认的映射。
为了解决这个问题，你可以在拦截器的配置中添加对静态资源的特殊处理。以腾讯云微服务框架Spring Cloud Tencent为例，你可以在配置类中添加如下代码：
```java
@Configuration
public class WebMvcConfig implements WebMvcConfigurer {
@Override
public void addInterceptors(InterceptorRegistry registry) {
registry.addInterceptor(new YourInterceptor()) // 添加你的拦截器
.addPathPatterns("/**") // 拦截所有请求
.excludePathPatterns("/static/**"); // 排除静态资源路径
}
}
```
这样，你的拦截器将不会影响到静态资源的访问。静态资源仍然可以通过/static/**的URL路径访问。
如果你使用的是Spring Boot原生配置，可以在`application.properties`或`application.yml`文件中添加以下配置：
```properties
spring.mvc.static-path-pattern=/static/**
```
或者在`WebMvcConfigurer`实现类中添加如下代码：
```java
@Override
public void configurePathMatch(PathMatchConfigurer configurer) {
configurer.addPathPrefix("/static", new StaticResourceLocation("classpath:/static/"));
}
```
这样可以确保静态资源目录被正确映射到URL。... 展开详请
安卓中引用static final修饰的变量为null，怎么解决
在安卓中，如果你想要引用一个被`static final`修饰的变量，但它的值为`null`，你可以尝试以下方法解决：
1. 确保变量被正确初始化：检查变量的初始化代码，确保它在声明时被赋予了一个非`null`的值。例如：
```java
public static final String MY_VARIABLE = "Hello, World!";
```
2. 使用`if`语句检查变量是否为`null`：在使用`static final`变量之前，你可以使用`if`语句检查它是否为`null`。如果是`null`，你可以采取适当的措施，例如抛出异常或使用默认值。例如：
```java
if (MY_VARIABLE == null) {
throw new IllegalStateException("MY_VARIABLE is null");
}
```
3. 使用腾讯云的云服务：腾讯云提供了多种云服务，可以帮助你解决各种问题。例如，腾讯云的云数据库可以帮助你存储和管理数据，云函数可以帮助你执行后端代码，云存储可以帮助你存储文件等。你可以根据你的需求选择合适的腾讯云产品。
请注意，`static final`变量在类加载时就会被初始化，因此在运行时它们的值不能被修改。如果你需要一个可以在运行时修改的变量，你应该使用其他修饰符，例如`static`或`final`。... 展开详请
Static 变量放在函数内外有什么区别
Static变量放在函数内外的区别在于它们的生命周期和作用范围。
如果将static变量放在函数内部，它将具有以下特点：
1. 生命周期：static变量在程序运行期间一直存在，直到程序结束。
2. 作用范围：static变量在函数内部定义，但其生命周期和作用范围与全局变量相似。它在整个程序范围内都可以访问，但只能在定义它的函数内部进行修改。
3. 初始化：static变量在程序开始运行时就已经分配了内存，并且只会被初始化一次。
如果将static变量放在函数外部，它将具有以下特点：
1. 生命周期：static变量在程序运行期间一直存在，直到程序结束。
2. 作用范围：static变量在函数外部定义，具有全局变量的作用范围。它可以在整个程序范围内进行访问和修改。
3. 初始化：static变量在程序开始运行时就已经分配了内存，并且只会被初始化一次。
在腾讯云中，您可以使用云函数SCF（Serverless Cloud Function）来实现无服务器架构，从而更好地管理和优化您的应用程序资源。通过使用SCF，您可以将函数与其他云服务（如API网关、COS对象存储等）集成，从而实现更高效、可扩展和可靠的应用程序。... 展开详请
Php什么时候用static
在 PHP 中，`static` 关键字用于声明静态变量、静态属性和静态方法。静态成员属于类本身，而不是类的实例。这意味着静态成员在类的所有实例之间共享，可以在没有创建类实例的情况下访问。
1. 静态变量：在函数内部声明的静态变量只在函数的第一次调用时初始化，之后的调用将保留上次调用时的值。这在需要保持函数内部变量的状态时非常有用。
```php
function counter() {
static $count = 0;
$count++;
echo $count;
}
counter(); // 输出 1
counter(); // 输出 2
counter(); // 输出 3
```
2. 静态属性：类的静态属性可以在不创建类实例的情况下访问。静态属性通常用于存储与类的所有实例共享的数据。
```php
class MyClass {
public static $counter = 0;
public function incrementCounter() {
self::$counter++;
}
}
$obj1 = new MyClass();
$obj1->incrementCounter();
echo MyClass::$counter; // 输出 1
$obj2 = new MyClass();
$obj2->incrementCounter();
echo MyClass::$counter; // 输出 2
```
3. 静态方法：类的静态方法可以在不创建类实例的情况下调用。静态方法不能访问类的非静态属性和方法。
```php
class MyClass {
public static function sayHello() {
echo "Hello!";
}
}
MyClass::sayHello(); // 输出 "Hello!"
```
腾讯云相关产品推荐：腾讯云提供了云服务器、云数据库、云存储等多种云计算产品，可以帮助您快速构建和部署 PHP 应用。您可以考虑使用腾讯云的云服务器（CVM）和云数据库（TencentDB）来部署和托管您的 PHP 应用。... 展开详请
static和final的区别是什么
static 关键字用于声明静态成员（变量和方法），而 final 关键字用于声明不可变成员（变量、方法或者类）。
静态成员属于类而不是属于某个对象。当一个类被加载时，静态成员就会被分配内存空间，且只分配一次。静态成员可以在没有创建类实例的情况下访问。
不可变成员一旦被赋值，就不能被修改。final 变量必须在声明时或构造方法中初始化，之后不能被修改。final 方法不能被子类覆盖。
举例：
```java
public class MyClass {
public static int staticVar = 10; // static 变量
public final int finalVar = 20; // final 变量
public static void staticMethod() { } // static 方法
public final void finalMethod() { } // final 方法
}
public class Main {
public static void main(String[] args) {
System.out.println(MyClass.staticVar); // 访问静态变量
MyClass obj = new MyClass();
System.out.println(obj.finalVar); // 访问 final 变量
MyClass.staticMethod(); // 调用静态方法
obj.finalMethod(); // 调用 final 方法
}
}
```
在云计算行业中，腾讯云产品有很多与 static 和 final 相关的特性。例如，在云服务器（CVM）中，静态 IP 和固定 IP 可以帮助用户固定 IP 地址，使公网访问更稳定。而存储产品（如对象存储 COS、文件存储 CFS 等）中的存储桶和文件可以设置为不可变，以保证数据安全性。... 展开详请
static在编程中的作用到底是什么
在编程中，`static`关键字用于表示一个变量或方法是静态的。静态变量和方法具有以下特点：
1. 静态变量：它们在整个程序运行期间保持其值，且只被初始化一次。静态变量在类加载时分配内存，因此它们的生命周期与类的生命周期相同。静态变量可以通过类名直接访问，而不需要创建类的实例。
例如：
```java
class MyClass {
static int staticVar = 10;
}
public class Main {
public static void main(String[] args) {
System.out.println(MyClass.staticVar); // 输出：10
}
}
```
2. 静态方法：它们也称为类方法，可以直接通过类名调用，而不需要创建类的实例。静态方法无法访问类的非静态成员，因为静态方法在类加载时就存在，而非静态成员是在类的实例创建时才存在的。
例如：
```java
class MyClass {
static int staticVar = 10;
static void staticMethod() {
System.out.println("Static method called");
}
}
public class Main {
public static void main(String[] args) {
MyClass.staticMethod(); // 输出：Static method called
}
}
```
在腾讯云中，静态变量和方法可以用于实现云服务的高可用性、负载均衡和自动扩展等功能。例如，腾讯云的负载均衡器（CLB）可以自动分配流量到不同的云服务器，从而实现负载均衡。而静态变量和方法可以用于存储和管理这些云服务器的状态信息。... 展开详请
C# 中的 public、static 和 void 关键字有什么区别
在C#编程语言中，public、static和void是三个不同的关键字，它们分别具有以下含义和用途：
1. public：这是一个访问修饰符，用于指定类成员（如方法、属性、字段等）的访问权限。将一个类成员声明为public意味着该成员可以在任何地方被访问，包括其他类、命名空间等。
示例：
```csharp
public class MyClass
{
public int MyProperty { get; set; }
}
```
在这个例子中，MyProperty属性被声明为public，因此可以在其他类中通过创建MyClass的实例来访问它。
2. static：这是一个修饰符，用于指定类成员是静态的，而不是实例的。静态成员属于类本身，而不是类的实例。静态成员可以在不创建类实例的情况下被访问。
示例：
```csharp
public class MyClass
{
public static int MyStaticProperty { get; set; }
}
```
在这个例子中，MyStaticProperty属性被声明为static，因此可以在不创建MyClass实例的情况下通过类名直接访问它，如：MyClass.MyStaticProperty。
3. void：这是一个返回类型，表示一个方法不返回任何值。当一个方法被声明为void时，它执行某些操作，但不返回任何结果。
示例：
```csharp
public class MyClass
{
public void MyMethod()
{
Console.WriteLine("Hello, World!");
}
}
```
在这个例子中，MyMethod方法被声明为void，因此它在执行时不会返回任何值。当调用这个方法时，它只会输出"Hello, World!"。
总结：public、static和void分别用于指定类成员的访问权限和返回类型，以及声明静态成员。在C#编程中，它们是非常重要的概念，开发者需要熟练掌握它们的使用。... 展开详请
为什么未命名的命名空间是静态的“高级”替代？
X：UWP XAML中的Static？
在UWP上没有静态标记扩展(也没有WinRT平台)。 可能的解决方案之一是创建类，将枚举值作为属性，并将该类的实例存储在ResourceDictionary中。 例子： public enum Weather
{
Cold,
Hot
} 下面是具有枚举值的类： public class WeatherEnumValues
{
public static Weather Cold
{
get
{
return Weather.Cold;
}
}
public static Weather Hot
{
get
{
return Weather.Hot;
}
}
} 在你的资源字典中： <local:WeatherEnumValues x:Key="WeatherEnumValues" /> 如下： "{Binding whatever, Converter={StaticResource converterName},
ConverterParameter={Binding Hot, Source={StaticResource WeatherEnumValues}}}" />... 展开详请
“static const”vs“#define”vs“enum”？
这取决于你需要什么价值。你（和其他人迄今为止）省略了第三种选择：
static const int var = 5;
#define var 5
enum { var = 5 };
忽略关于选择名称的问题，那么：
如果你需要传递一个指针，你必须使用（1）。
由于（2）显然是一个选项，你不需要传递指针。
（1）和（3）在调试器的符号表中都有一个符号 - 这使调试更容易。（2）更有可能没有象征，让你想知道它是什么。
（1）不能用作全球范围数组的维度; （2）和（3）都可以。
（1）不能用作函数范围内静态数组的维度; （2）和（3）都可以。
在C99下，所有这些都可以用于本地阵列。从技术上讲，使用（1）意味着使用VLA（可变长度数组），虽然“var”引用的维度当然会被固定为5。
（1）不能用在switch语句的地方; （2）和（3）都可以。
（1）不能用来初始化静态变量; （2）和（3）都可以。
（2）可以改变你不想改变的代码，因为它被预处理器使用; （1）和（3）都不会有这样的意想不到的副作用。
您可以检测（2）是否已经在预处理器中设置; （1）和（3）都不允许。
所以，在大多数情况下，更喜欢“枚举”。否则，第一个和最后一个要点可能是控制因素 - 如果你需要同时满足这两个要点，你必须更加努力地思考。
如果你问的是C ++，那么每次都使用选项（1） - 静态常量。... 展开详请
腾讯云开发者
