blocks|key|3882199|text|你说的“发现”是什么意思？|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3882200|这条线|3882201|#define+count+1|code-block|syntax|javascript|3882202|定义一个值为1的符号"count“。|3882203|编译过程的第一步(称为预处理)会将每次出现的符号计数替换为1，因此如果您有：|3882204|if+(x+>+count)+...|3882205|它将被替换为：|3882206|if+(x+>+1)+...|3882207|如果你明白了这一点，你可能会明白为什么“查找count”是没有意义的。|3882208|entityMap^0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|X|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|Y|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|Z|8|@]|9|@]|A|$]]|$1|K|3|L|5|6|7|10|8|@]|9|@]|A|$]]|$1|M|3|N|5|F|7|11|8|@]|9|@]|A|$G|H]]|$1|O|3|P|5|6|7|12|8|@]|9|@]|A|$]]|$1|Q|3|R|5|F|7|13|8|@]|9|@]|A|$G|H]]|$1|S|3|T|5|6|7|14|8|@]|9|@]|A|$]]|$1|U|3|-4|5|6|7|15|8|@]|9|@]|A|$]]]|V|$]]

What do you mean by "finding"?

The line 

<pre><code>#define count 1
</code></pre>

defines a symbol "count" that has value 1.

The first step of the compilation process (called preprocessing) will replace every occurence of the symbol count with 1 so that if you have:

<pre><code>if (x &gt; count) ...
</code></pre>

it will be replaced by:

<pre><code>if (x &gt; 1) ...
</code></pre>

If you get this, you may see why "finding count" is meaningless.

blocks|key|3037140|text|#define是预处理器指令，因此它不是“变量”|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|3037141|entityMap^0|0|7|0^^$0|@$1|2|3|4|5|6|7|H|8|@$9|I|A|J|B|C]]|D|@]|E|$]]|$1|F|3|-4|5|6|7|K|8|@]|D|@]|E|$]]]|G|$]]

<code>#define</code> is a pre-processor directive, as such it is not a "variable"

blocks|key|3882275|text|C定义是一个预处理器指令，而不是一个变量。在编译之前，预处理器将遍历你的C文件，并将你编写count的地方替换为你定义的地方。查看混淆的C竞赛参赛作品，了解this和其他预处理器指令的一些特别开明的用法。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3882276|关键是没有'count‘可以指向'1’值。这只是一个简单的/find替换操作，甚至在代码真正编译之前就发生了。|3882277|我将把这个可编辑的代码留给真正了解C的人去纠正。|3882278|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|H|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|I|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|J|8|@]|9|@]|A|$]]|$1|F|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|G|$]]

C defines are a pre-processor directive, not a variable. The pre-processor will go through your C file and replace where you write count with what you've defined it as, before compiling. Look at the obfuscated C contest entries for some particularly enlightened uses of this and other pre-processor directives. 

The point is that there is no 'count' to point at a '1' value. It just a simple/find replace operation that happens before the code is even really compiled.

I'll leave this editable for someone who actually really knows C to correct.

blocks|key|771851|text|该用户是否可以使用变量名“|type|unstyled|depth|inlineStyleRanges|entityRanges|data|771852|”中的1找到该变量名？|blockquote|771853|771854|不是|771855|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|J|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|K|8|@]|9|@]|A|$]]|$1|E|3|-4|5|6|7|L|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|M|8|@]|9|@]|A|$]]|$1|H|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|I|$]]

<blockquote>
 <blockquote>
 Can that person find the variable name "count" using the 1 that is inside it?
 </blockquote>
</blockquote>

No

blocks|key|3882354|text|答案很简单，他们不能。#像这样的定义是由预处理器处理的，它们只指向一个方向。当然，另一个问题是，即使是编译器也不会知道--因为"1“可以指向任何东西--多个变量可以同时具有相同的值。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3882355|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

The simple answer is no they can't. #Defines like that are dealt with by the preprocessor, and they only point in one direction. Of course the other problem is that even the compiler wouldn't know - as a "1" could point to anything - multiple variables can have the same value at the same time.

blocks|key|774566|text|我相信比我更能言善辩的人会指出#define'd+thing没有编译到源代码中，你所拥有的是一个预处理器宏，它将遍历源代码并用'1‘更改它找到的'count’的所有实例。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|774567|然而，为了更好地解释被问到的问题，因为C语言是一种编译语言，深入到机器代码，你永远不会有像Java或C#这样的语言所具有的反思和自省。所有的命名在编译后都会丢失，除非你有一个围绕源代码/编译器构建的框架来做一些漂亮的事情。|774568|希望这个能帮上忙。(请原谅我的双关语)|774569|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|H|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|I|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|J|8|@]|9|@]|A|$]]|$1|F|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|G|$]]

As I'm sure someone more eloquent and versed than me will point out #define'd things aren't compiled into the source, what you have is a pre-processor macro which will go through the source and change all instance of 'count' it finds with a '1'.

However, to shed more light on the question you were asked, because C is a compiled language down to the machine code you are never going to have the reflection and introspection you have with a language like Java, or C#. All the naming is lost after compilation unless you have a framework built around your source/compiler to do some nifty stuff.

Hope this helps. (excuse the pun)

blocks|key|5293285|text|你所拥有的实际上不是一个变量，它是一个预处理器指令。编译代码时，预处理器将遍历该文件中“count”一词的所有实例，并将其替换为1。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|5293286|你可能会问我是否知道1我能找到它的计数点吗？不是的。因为变量名和值之间的关系不是双向映射，所以没有回头路可走。考虑一下|5293287|int+count+=+1;
int+count2+=+1;|code-block|syntax|javascript|5293288|完全合法，但我应该解决什么问题呢？|5293289|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|N|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|O|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|P|8|@]|9|@]|A|$]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

What you have there is actually not a variable, it is a preprocessor directive. When you compile the code the preprocessor will go through and replace all instaces of the word 'count' in that file with 1.

You might be asking if I know 1 can I find that count points to it? No. Because the relationship between variables names and values is not a bijection there is no way back. Consider

<pre><code>int count = 1;
int count2 = 1;
</code></pre>

perfectly legal but what should 1 resolve to?

blocks|key|3882584|text|基于@Cade+Roux的回答，如果使用预处理器#define将值与符号关联，则一旦预处理器运行，代码将不会有任何对符号的引用：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3882585|#define+COUNT+(1)
...
int+myVar+=+COUNT;
...|code-block|syntax|javascript|3882586|预处理器运行后：|3882587|...
int+myVar+=+(1);
...|3882588|因此，正如其他人所指出的，由于上述原因，这基本上意味着“不”。|3882589|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Q|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|R|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|S|8|@]|9|@]|A|$]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

Building on @Cade Roux's answer, if you use a preprocessor #define to associate a value with a symbol, the code won't have any reference to the symbol once the preprocessor has run:

<pre><code>#define COUNT (1)
...
int myVar = COUNT;
...
</code></pre>

After the preprocessor runs:

<pre><code>...
int myVar = (1);
...
</code></pre>

So as others have noted, this basically means "no", for the above reason.

blocks|key|771989|text|一般来说，不是。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|771990|首先，#define不是一个变量，它是一个编译器预处理器宏。|771991|当编译器的主要阶段开始工作时，名称已经被值替换，并且名称"count“将不存在于编译的代码中的任何地方。|771992|对于变量，不可能在运行时找出C代码中的变量名称。这些信息不会被保留。与Java或C#等语言不同，C语言在编译成汇编语言时根本不保留太多的元数据。|771993|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|J|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|K|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|L|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|M|8|@]|9|@]|A|$]]|$1|H|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|I|$]]

In general, no.

Firstly, a #define is not a variable, it is a compiler preprocessor macro.

By the time the main phase of the compiler gets to work, the name has been replaced with the value, and the name "count" will not exist anywhere in the code that is compiled.

For variables, it is not possible to find out variable names in C code at runtime. That information is not kept. Unlike languages like Java or C#, C does not keep much metadata at all, in compiles down to assembly language.

blocks|key|3037647|text|以"#“开头的指令由预处理器处理，它通常在将代码传递给”real“编译器之前进行文本替换。因此，没有名为count的变量，就好像代码中所有的"count“字符串都被神奇地替换为"1”字符串。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3037648|所以，不，没有办法找到那个“变量”。|3037649|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

Directive starting with "#" are handled by the pre-processor which usually does text substitution before passing the code to the 'real' compiler. As such, there is no variable called count, it's as if all "count" strings in your code are magically replaced with the "1" string.

So, no, no way to find that "variable".

blocks|key|5293526|text|如果是宏，则对其进行预处理，并编译生成的输出。所以绝对找不到这个名字，因为在预处理器完成他的工作之后，生成的文件将包含'1‘，而不是'count’。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|5293527|所以答案是否定的。|5293528|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

In case of a macro this is preprocessed and the resulting output is compiled. So it is absolutely no way to find out that name because after the preprocessor finnishes his job the resulting file would contain '1' instead of 'count' everywhere in the file.

So the answer is no.

blocks|key|5293580|text|不幸的是，这是不可能的。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|5293581|#define语句是预处理器的指令，count的所有实例都被1替换。在运行时，没有与count相关联的内存位置，因此这种努力显然是徒劳的。|offset|length|style|CODE|5293582|即使您使用的是变量，编译后也不会有程序中使用的原始标识符的残留物。这通常只在动态语言中是可能的。|5293583|entityMap^0|0|0|7|I|5|U|1|16|5|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|M|8|@$D|N|E|O|F|G]|$D|P|E|Q|F|G]|$D|R|E|S|F|G]|$D|T|E|U|F|G]]|9|@]|A|$]]|$1|H|3|I|5|6|7|V|8|@]|9|@]|A|$]]|$1|J|3|-4|5|6|7|W|8|@]|9|@]|A|$]]]|K|$]]

Unfortunately this is not possible.

<code>#define</code> statements are instructions for the preprocessor, all instances of <code>count</code> are replaced with <code>1</code>. At runtime there is no memory location associated with <code>count</code>, so the effort is obviously futile.

Even if you're using variables, after compilation there will be no remnants of the original identifiers used in the program. This is generally only possible in dynamic languages.

blocks|key|3037785|text|如果他们正在查看C源代码(他们将在调试器中)，那么他们将看到类似这样的内容|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3037786|int+i+=+count;|code-block|syntax|javascript|3037787|在这一点上，他们可以向后搜索并找到行|3037788|#define+count+1|3037789|然而，如果他们所拥有的都是变量计数，并且他们可以看到它包含1，那么就没有办法追溯到‘iDontKnowWhat’。|3037790|为什么？因为#define是在预处理器时计算的，这甚至在编译之前就发生了(尽管对于几乎所有人来说，它都可以被视为编译的第一阶段)。因此，源代码是唯一有关于“count”的信息的东西，比如知道它曾经存在过。在编译器查看时，对“count”的每个引用都已替换为数字“1”。|3037791|entityMap^0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|R|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|S|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|T|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|U|8|@]|9|@]|A|$]]|$1|M|3|N|5|6|7|V|8|@]|9|@]|A|$]]|$1|O|3|-4|5|6|7|W|8|@]|9|@]|A|$]]]|P|$]]

If they are looking at the C source code (which they will be in a debugger), then they will see something like

<pre><code>int i = count;
</code></pre>

at that point, they can search back and find the line 

<pre><code>#define count 1
</code></pre>

If, however, all they have is variable iDontKnowWhat, and they can see it contans 1, there is no way to track that back to 'count'. 

Why? Because the #define is evaluated at preprocessor time, which happens even before compilation (though for almost everyone, it can be viewed as the first stage of compilation). Consequently the source code is the only thing that has any information about 'count', like knowing that it ever existed. By the time the compiler gets a look in, every reference to 'count' has been replaced by the number '1'.

blocks|key|772145|text|它不是一个指针，它只是一个字符串/标记替换。在编译代码之前，预处理器会替换掉所有的#定义。大多数编译器都包含一个-E或类似的参数来发出预编译代码，因此您可以看到在处理完所有#指令之后代码是什么样子。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|772146|对于您的问题，更直接的说法是，无法在代码中断定某个令牌正在被替换。您的代码甚至无法分辨(count+==+1)和(1+==+1)之间的区别。|772147|如果你真的想这样做，也许可以使用源文件文本分析，比如使用diff工具。|772148|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|H|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|I|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|J|8|@]|9|@]|A|$]]|$1|F|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|G|$]]

It's not a pointer, it's just a string/token substitution. The preprocessor replaces all the #defines before your code ever compiles. Most compilers include a -E or similar argument to emit precompiled code, so you can see what the code looks like after all the #directives are processed.

More directly to your question, there's no way to tell that a token is being replaced in code. Your code can't even tell the difference between (count == 1) and (1 == 1).

If you really want to do that, it might be possible using source file text analysis, say using a diff tool.

blocks|key|5293755|text|在C中使用的一个技巧是在宏中使用#语法来获取宏参数的字符串文字。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|5293756|#define+displayInt(val)+printf("%25s:+%25d\n",#val,val)
#define+displayFloat(val)+printf("%25s:+%25d\n",#val,val)
#define+displayString(val)+printf("%25s:+%25s\n",#val,val)

int+main(){
++int+foo=123;
++float+bar=456.789;
++char+thud[]="this+is+a+string";

++displayInt(foo);
++displayFloat(bar);
++displayString(thud);

++return+0;
}|code-block|syntax|javascript|5293757|输出应如下所示：|5293758|foo:+123
bar:+456.789
thud:+this+is+a+string|5293759|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

One trick used in C is using the # syntax in macros to obtain the string literal of the of the macro parameter.

<pre><code>#define displayInt(val) printf("%s: %d\n",#val,val)
#define displayFloat(val) printf("%s: %d\n",#val,val)
#define displayString(val) printf("%s: %s\n",#val,val)

int main(){
 int foo=123;
 float bar=456.789;
 char thud[]="this is a string";

 displayInt(foo);
 displayFloat(bar);
 displayString(thud);

 return 0;
}
</code></pre>

The output should look something like the following:

<pre><code>foo: 123
bar: 456.789
thud: this is a string
</code></pre>

blocks|key|3883051|text|问问题的人(这是面试问题吗？)可能一直试图让您区分使用#define常量和枚举。例如：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3883052|#define+ZERO+0
#define+ONE+1
#define+TWO+2|code-block|syntax|javascript|3883053|vs|3883054|enum+{
++ZERO,
++ONE,
++TWO
};|3883055|给定代码：|3883056|x+=+TWO;|3883057|如果您使用枚举而不是#定义，一些调试器将能够向您显示值的符号形式2，而不仅仅是数值2。|3883058|entityMap^0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|T|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|U|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|V|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|W|8|@]|9|@]|A|$]]|$1|M|3|N|5|D|7|X|8|@]|9|@]|A|$E|F]]|$1|O|3|P|5|6|7|Y|8|@]|9|@]|A|$]]|$1|Q|3|-4|5|6|7|Z|8|@]|9|@]|A|$]]]|R|$]]

The person asking the question (was it an interview question?) may have been trying to get you to differentiate between using #define constants versus enums. For example:

<pre><code>#define ZERO 0
#define ONE 1
#define TWO 2
</code></pre>

vs

<pre><code>enum {
 ZERO,
 ONE,
 TWO
};
</code></pre>

Given the code:

<pre><code>x = TWO;
</code></pre>

If you use enumerations instead of the #defines, some debuggers will be able to show you the symbolic form of the value, TWO, instead of just the numeric value of 2.

blocks|key|3883219|text|count不是一个变量。它没有分配给它的存储空间，在符号表中也没有条目。它是一个在将源代码传递给编译器之前由预处理器替换的宏。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|3883220|如果您没有问对问题，有一种方法可以使用宏获取名称：|3883221|#define+SHOW(sym)+(printf(#sym+"+=+%25d\n",+sym))
#define+count+1

SHOW(count);+//+prints+"count+=+1"|code-block|syntax|javascript|3883222|#运算符将宏参数转换为字符串文字。|3883223|entityMap^0|0|5|0|0|0|0|1|0^^$0|@$1|2|3|4|5|6|7|Q|8|@$9|R|A|S|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|T|8|@]|D|@]|E|$]]|$1|H|3|I|5|J|7|U|8|@]|D|@]|E|$K|L]]|$1|M|3|N|5|6|7|V|8|@$9|W|A|X|B|C]]|D|@]|E|$]]|$1|O|3|-4|5|6|7|Y|8|@]|D|@]|E|$]]]|P|$]]

<code>count</code> isn't a variable. It has no storage allocated to it and no entry in the symbol table. It's a macro that gets replaced by the preprocessor before passing the source code to the compiler.

On the off chance that you aren't asking quite the right question, there is a way to get the name using macros:

<pre><code>#define SHOW(sym) (printf(#sym " = %d\n", sym))
#define count 1

SHOW(count); // prints "count = 1"
</code></pre>

The <code>#</code> operator converts a macro argument to a string literal.

blocks|key|775017|text|#define+count+1是一个非常糟糕的想法，因为它阻止您将任何变量或结构字段命名为count。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|775018|例如：|775019|void+copyString(char*+dst,+const+char*+src,+size_t+count)+{
+++...
}|code-block|syntax|javascript|775020|您的count宏将导致变量名替换为1，从而阻止此函数编译：|775021|void+copyString(char*+dst,+const+char*+src,+size_t+1)+{
+++...
}|775022|entityMap^0|0|F|19|5|0|0|0|2|5|H|1|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@$9|T|A|U|B|C]|$9|V|A|W|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|X|8|@]|D|@]|E|$]]|$1|H|3|I|5|J|7|Y|8|@]|D|@]|E|$K|L]]|$1|M|3|N|5|6|7|Z|8|@$9|10|A|11|B|C]|$9|12|A|13|B|C]]|D|@]|E|$]]|$1|O|3|P|5|J|7|14|8|@]|D|@]|E|$K|L]]|$1|Q|3|-4|5|6|7|15|8|@]|D|@]|E|$]]]|R|$]]

<code>#define count 1</code> is a very bad idea, because it prevents you from naming any variables or structure fields <code>count</code>. 

For example:

<pre><code>void copyString(char* dst, const char* src, size_t count) {
 ...
}
</code></pre>

Your <code>count</code> macro will cause the variable name to be replaced with <code>1</code>, preventing this function from compiling:

<pre><code>void copyString(char* dst, const char* src, size_t 1) {
 ...
}
</code></pre>

I was asked a question in C last night and I did not know the answer since I have not used C much since college so I thought maybe I could find the answer here instead of just forgetting about it.

If a person has a define such as:

<pre><code>#define count 1
</code></pre>

Can that person find the variable name <code>count</code> using the 1 that is inside it?

I did not think so since I thought the count would point to the 1 but do not see how the 1 could point back to count.

Finding the name of a variable in C

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

昨晚我被问了一个C语言的问题，我不知道答案，因为我从大学开始就不太用C了，所以我想也许我可以在这里找到答案，而不是忘记它。如果一个人有这样的定义：#define count 1该用户是否可以使用变量名count中的1找到该变量？我不这样认为，因为我认为计数会指向1，但看不到1如何指向count。

问在C++中查找变量名
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问在C++中查找变量名EN