blocks|key|2084627|text|因为它们是完全不同的。第一个是带有初始化表达式的变量的定义，即(指针本身的初始化+)：|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|2084628|int+*+++++++++q++++++++++++++++++++++=+8;
~~~~~+++++++++~++++++++++++++++++++++~~~
type+is+int*;+name+of+variable+is+q;+initialized+with+8|code-block|syntax|javascript|2084629|第二个是赋值(指针指向的对象)：|2084630|*q++++++++++++++++++++++++++++++=+6;
~~++++++++++++++++++++++++++++++~~~
dereference+on+q+via+operator*;+assign+the+resulting+lvalue+pointed+by+q+to+6|2084631|而且，int+*p+=+6;意味着用int*类型定义一个名为p的变量，并使用6初始化它，这是因为6不能直接用于初始化指针(即错误“从'int‘到’int*‘的无效转换”)。|style|CODE|2084632|entityMap|0|LINK|mutability|MUTABLE|url|http://en.cppreference.com/w/cpp/language/copy_initialization^0|11|3|0|0|0|0|0|3|B|I|4|U|1|12|1|1C|1|0^^$0|@$1|2|3|4|5|6|7|Y|8|@]|9|@$A|Z|B|10|1|11]]|C|$]]|$1|D|3|E|5|F|7|12|8|@]|9|@]|C|$G|H]]|$1|I|3|J|5|6|7|13|8|@]|9|@]|C|$]]|$1|K|3|L|5|F|7|14|8|@]|9|@]|C|$G|H]]|$1|M|3|N|5|6|7|15|8|@$A|16|B|17|O|P]|$A|18|B|19|O|P]|$A|1A|B|1B|O|P]|$A|1C|B|1D|O|P]|$A|1E|B|1F|O|P]]|9|@]|C|$]]|$1|Q|3|-4|5|6|7|1G|8|@]|9|@]|C|$]]]|R|$S|$5|T|U|V|C|$W|X]]]]

Because they're different things at all. The 1st one is definition of variable with initializer expression, i.e an <a href="http://en.cppreference.com/w/cpp/language/copy_initialization" rel="nofollow noreferrer">initialization</a> (of the pointer itself):

<pre><code>int * q = 8;
~~~~~ ~ ~~~
type is int*; name of variable is q; initialized with 8
</code></pre>

The 2nd one is assignment (of the object pointed by the pointer):

<pre><code>*q = 6;
~~ ~~~
dereference on q via operator*; assign the resulting lvalue pointed by q to 6
</code></pre>

And, <code>int *p = 6;</code> means define a variable named <code>p</code> with type <code>int*</code> and initialize it with <code>6</code>, which fails because <code>6</code> can't be used for initializing a pointer directly (i.e. the error "invalid conversion from 'int' to 'int*'").

blocks|key|787764|text|*符号用于代码片段中的两种不同的紫色。它第一次被用作类型声明int+*的一部分，声明指向int的指针。第二次用于取消指针*q的引用，调用间接操作符。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|787765|*也可用于调用乘法运算符*q+=+*q+*+*q;；|787766|若要将值赋值给指针所指向的整数，您需要取消引用它。要将除0以外的整数值赋值给指针本身(即int+*q+=+8;正在做的事情)，需要reinterpret_cast，因此您将得到此错误。|787767|entityMap^0|0|1|U|5|1O|2|0|0|1|C|D|0|18|B|1T|G|0^^$0|@$1|2|3|4|5|6|7|L|8|@$9|M|A|N|B|C]|$9|O|A|P|B|C]|$9|Q|A|R|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|S|8|@$9|T|A|U|B|C]|$9|V|A|W|B|C]]|D|@]|E|$]]|$1|H|3|I|5|6|7|X|8|@$9|Y|A|Z|B|C]|$9|10|A|11|B|C]]|D|@]|E|$]]|$1|J|3|-4|5|6|7|12|8|@]|D|@]|E|$]]]|K|$]]

<code>*</code> symbol is reused for two different purpuses in your snippet. First time it is used as a part of type declaration <code>int *</code>, declaring a pointer to int. Second time it is used to dereference a pointer <code>*q</code>, invoking indirection operator.

<code>*</code> can also be used to invoke multiplication operator <code>*q = *q * *q;</code>;

To assign a value to an integer pointed by pointer you need to dereference it. And to assigning integral value other than 0 to a pointer itself (that is what <code>int *q = 8;</code> is doing) requires <code>reinterpret_cast</code>, hence you get this error.

blocks|key|2123723|text|语句int+*q定义一个类型为“指针到整数”的变量，因此初始化需要是指针值，而不是整数值。因此，int+*q+=+8与int+*q;+*q+=+8不一样(这将是未定义的行为，因为它会取消未初始化的指针)，但更像int+*q;+q+=+8，这使得误解更加透明。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|2123724|entityMap^0|2|6|1C|A|1N|E|2X|D|0^^$0|@$1|2|3|4|5|6|7|H|8|@$9|I|A|J|B|C]|$9|K|A|L|B|C]|$9|M|A|N|B|C]|$9|O|A|P|B|C]]|D|@]|E|$]]|$1|F|3|-4|5|6|7|Q|8|@]|D|@]|E|$]]]|G|$]]

Statement <code>int *q</code> defines a variable of type "pointer to integer", and an initialisation therefore needs to be a pointer value, not an integral value.
So <code>int *q = 8</code> is not the same as <code>int *q; *q = 8</code> (which would be undefined behaviour because it dereferences an uninitialized pointer), but more like <code>int *q; q = 8</code>, which makes the misunderstanding more transparent.

blocks|key|787887|text|这是：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|787888|int+*q+=+8;|code-block|syntax|javascript|787889|是初始化。它初始化q+(指针)，而不是*q+(它所指向的)。用赋值(而不是初始化)同等地编写此代码，如下所示：|offset|length|style|CODE|787890|int+*q;
q+=+8;|787891|所以你看这没什么意义。(当然，也不允许-+int不是指针)|787892|为了确定，如果你写：|787893|int+*q;
*q+=+8;|787894|这在语法上是正确的，但没有定义。您的指针没有指向int类型的对象，而是未初始化的，可能指向某个无效位置。在那里写字，任何事情都可能发生。|787895|entityMap^0|0|0|9|1|J|2|0|0|L|3|0|0|0|O|3|0^^$0|@$1|2|3|4|5|6|7|Y|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|Z|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|10|8|@$I|11|J|12|K|L]|$I|13|J|14|K|L]]|9|@]|A|$]]|$1|M|3|N|5|D|7|15|8|@]|9|@]|A|$E|F]]|$1|O|3|P|5|6|7|16|8|@$I|17|J|18|K|L]]|9|@]|A|$]]|$1|Q|3|R|5|6|7|19|8|@]|9|@]|A|$]]|$1|S|3|T|5|D|7|1A|8|@]|9|@]|A|$E|F]]|$1|U|3|V|5|6|7|1B|8|@$I|1C|J|1D|K|L]]|9|@]|A|$]]|$1|W|3|-4|5|6|7|1E|8|@]|9|@]|A|$]]]|X|$]]

This:

<pre><code>int *q = 8;
</code></pre>

is an initialization. It initializes <code>q</code> (the pointer), not <code>*q</code> (what it points to). Writing this equivalently with an assignment instead of initialization would look like:

<pre><code>int *q;
q = 8;
</code></pre>

So you see it doesn't make sense. (and, isn't allowed of course -- an <code>int</code> is not a pointer)

Just to be sure, if you write:

<pre><code>int *q;
*q = 8;
</code></pre>

this is syntactically correct, but undefined behavior. Your pointer doesn't point to an object of type <code>int</code>, it is uninitialized and probably pointing to some invalid location. Writing there, anything could happen.

blocks|key|2123769|text|因为类型不匹配。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2123770|6本身不是指针类型的值，它是一个整数，因此不能直接存储在指针中。|offset|length|style|CODE|2123771|当您执行*q+=+6时，*取消指针，所以类型变成int+(或者更确切地说，是一个lvalue+int，也就是可以分配给它的东西)。|2123772|entityMap^0|0|0|1|0|4|6|C|1|O|3|1B|3|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]]|9|@]|A|$]]|$1|H|3|I|5|6|7|P|8|@$D|Q|E|R|F|G]|$D|S|E|T|F|G]|$D|U|E|V|F|G]|$D|W|E|X|F|G]]|9|@]|A|$]]|$1|J|3|-4|5|6|7|Y|8|@]|9|@]|A|$]]]|K|$]]

Because the types don't match.

The <code>6</code> itself is not a value of pointer type, it's an integer so it cannot be directly stored in a pointer.

When you do <code>*q = 6</code> the <code>*</code> dereferences the pointer, so the type becomes <code>int</code> (or rather an lvalue <code>int</code>, i.e. something that can be assigned to).

blocks|key|2084703|text|在这里，将值8赋值给int*类型的对象。这意味着q点在内存中的地址8上。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|2084704|+int+*q+=+8;|code-block|syntax|javascript|2084705|是否将等效为：|BOLD|2084706|int+*q;
q+=+8;|2084707|是否不等效于以下：|2084708|int+*q;
*q+=+8;|2084709|是非法，因为它涉及约束违反。|2084710|相关堆栈溢出问题：是否可以将C指针初始化为NULL？|2084711|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/questions/43338084/is-it-possible-to-initialize-a-c-pointer-to-null^0|6|1|A|4|O|1|X|1|0|0|3|3|0|0|2|6|0|0|1|2|9|4|0|9|H|0|0^^$0|@$1|2|3|4|5|6|7|15|8|@$9|16|A|17|B|C]|$9|18|A|19|B|C]|$9|1A|A|1B|B|C]|$9|1C|A|1D|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|1E|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|1F|8|@$9|1G|A|1H|B|M]]|D|@]|E|$]]|$1|N|3|O|5|H|7|1I|8|@]|D|@]|E|$I|J]]|$1|P|3|Q|5|6|7|1J|8|@$9|1K|A|1L|B|M]]|D|@]|E|$]]|$1|R|3|S|5|H|7|1M|8|@]|D|@]|E|$I|J]]|$1|T|3|U|5|6|7|1N|8|@$9|1O|A|1P|B|M]|$9|1Q|A|1R|B|M]]|D|@]|E|$]]|$1|V|3|W|5|6|7|1S|8|@]|D|@$9|1T|A|1U|1|1V]]|E|$]]|$1|X|3|-4|5|6|7|1W|8|@]|D|@]|E|$]]]|Y|$Z|$5|10|11|12|E|$13|14]]]]

Here, assign the value <code>8</code> to an object of type <code>int*</code>. It means <code>q</code> points on address <code>8</code> on memory.

<pre><code> int *q = 8;
</code></pre>

Is equivalent to:

<pre><code>int *q;
q = 8;
</code></pre>

Is Not equivalent to:

<pre><code>int *q;
*q = 8;
</code></pre>

is illegal, as it involves constraint violation.

Related stack overflow question: <a href="https://stackoverflow.com/questions/43338084/is-it-possible-to-initialize-a-c-pointer-to-null">Is it possible to initialize a C pointer to NULL?</a>

blocks|key|788071|text|指针变量保存某物的地址或“位置”。因此，指针保存一个值，该值是一个内存地址。当你说：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|788072|int+*q+=+6;|code-block|syntax|javascript|788073|您正在创建一个指向int的指针变量，并告诉它指向存储在地址6中的int值，这可能不是您真正想要的。|788074|指针变量应指向包含要访问的实际数据的某些内存地址。例如：|788075|int+x+=+5;
int+*q+=+&x;|788076|这将创建一个包含值5的变量(+x+)。下一行将创建一个包含x地址的指针变量。您已经将指针变量'q‘设置为int变量'x’的地址。|788077|现在，您可以通过这样做来查看“x”的内容：|788078|int+y;
y+=+*q;|788079|这句话写着“取q所指的内容，并将其存储在y中”。最终的效果是y将被设置为5。|788080|int+x+=+5;+++++//+create+variable+x+and+set+it+to+5
int+*q+=+&x;+++//+create+int+pointer+variable,+set+it+to+the+address+of+x
int+y;+++++++++//+create+variable+y
y+=+*q;++++++++//+take+the+value+pointed+to+by+q,+and+store+it+in+y|788081|例如，如果变量x位于内存位置1234，而您查看了存储在'q‘中的值，则为1234，即x的地址。当您说"y+=+*q“时，您说的是”获取存储在地址1234中的值，并将该值放入y“。由于存储器位置1234是'x'，并且'x‘被分配给值5，值5将是存储在地址1234中的值。|788082|y+=+*q;|788083|将获取存储在地址1234中的值，并将y赋值给该值，从而使y+5成为存储在x中的值，这就是q‘所指向的值。|788084|这可以缩短为：|788085|int+x+=+5;
int+*q+=+&x;
int+y+=+*q;|788086|entityMap^0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|18|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|19|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|1A|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|1B|8|@]|9|@]|A|$]]|$1|K|3|L|5|D|7|1C|8|@]|9|@]|A|$E|F]]|$1|M|3|N|5|6|7|1D|8|@]|9|@]|A|$]]|$1|O|3|P|5|6|7|1E|8|@]|9|@]|A|$]]|$1|Q|3|R|5|D|7|1F|8|@]|9|@]|A|$E|F]]|$1|S|3|T|5|6|7|1G|8|@]|9|@]|A|$]]|$1|U|3|V|5|D|7|1H|8|@]|9|@]|A|$E|F]]|$1|W|3|X|5|6|7|1I|8|@]|9|@]|A|$]]|$1|Y|3|Z|5|D|7|1J|8|@]|9|@]|A|$E|F]]|$1|10|3|11|5|6|7|1K|8|@]|9|@]|A|$]]|$1|12|3|13|5|6|7|1L|8|@]|9|@]|A|$]]|$1|14|3|15|5|D|7|1M|8|@]|9|@]|A|$E|F]]|$1|16|3|-4|5|6|7|1N|8|@]|9|@]|A|$]]]|17|$]]

A pointer variable holds an address, or 'location' of something. Thus, the pointer holds a value that is a memory address. When you say:

<pre><code>int *q = 6;
</code></pre>

you are creating a pointer variable that intends to point to an int, and telling it to point to the int value stored in the address 6, which is (probably) not what you really intended.

A pointer variable should point to some memory address that contains some actual data you want to access. For example:

<pre><code>int x = 5;
int *q = &amp;x;
</code></pre>

This creates a variable (x) that contains the value 5.
the next line creates a pointer variable that contains the address of x. You have set the pointer variable 'q' to the address of the int variable 'x'.

Now you can see what is at 'x' by doing this:

<pre><code>int y;
y = *q;
</code></pre>

This says "take what is pointed to by q, and store it in y". The end effect is that y will be set to 5.

<pre><code>int x = 5; // create variable x and set it to 5
int *q = &amp;x; // create int pointer variable, set it to the address of x
int y; // create variable y
y = *q; // take the value pointed to by q, and store it in y
</code></pre>

If, for example the variable x is at memory location 1234, and you looked at the value stored in 'q', it would be 1234, which is the address of x.
When you say "y = *q", you are saying "take the value stored in the address 1234, and puts that value in y". Since the memory location 1234 is 'x', and 'x' was assigned the value 5, the value 5 will be what is stored at the address 1234.

<pre><code>y = *q;
</code></pre>

will take the value stored in the address 1234 and assign y to that value, thus making y 5, which was the value stored in x, which is what q 'points' to.

This could be shortened to:

<pre><code>int x = 5;
int *q = &amp;x;
int y = *q;
</code></pre>

blocks|key|2123969|text|当你写|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2123970|int+*q+=+8;，它意味着您声明了一个指针q，并用整数8初始化了一个指针。但是，作为一个指针，Q需要一个address+value，因此您会得到一个错误，说明不兼容。|offset|length|style|CODE|2123971|而当你写的时候|2123972|*q=8声明后，这意味着您要取消引用q指出的地址，并将值写入该位置。在这里，q指向一个int，所以您要将8一个整数值写入q指向的位置。这是对的。如果没有初始化q以指向正确的位置，这也会在运行时导致错误。|2123973|entityMap^0|0|0|B|O|1|1J|D|0|0|0|4|I|1|12|1|17|3|1G|1|1O|1|27|1|0^^$0|@$1|2|3|4|5|6|7|N|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|O|8|@$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|K|5|6|7|W|8|@$D|X|E|Y|F|G]|$D|Z|E|10|F|G]|$D|11|E|12|F|G]|$D|13|E|14|F|G]|$D|15|E|16|F|G]|$D|17|E|18|F|G]|$D|19|E|1A|F|G]]|9|@]|A|$]]|$1|L|3|-4|5|6|7|1B|8|@]|9|@]|A|$]]]|M|$]]

When you write 
<code>int *q = 8;</code> it means you declared a pointer <code>q</code> and initialized a pointer with the integer 8. but q being a pointer expects a <code>address value</code> therefore you get error stating incompatibility. 
Whereas when you write 
<code>*q=8</code> after declaring, it means you are dereferencing the addresses pointed by <code>q</code> and writing a value to that location. here <code>q</code> points to a <code>int</code> so you are writing <code>8</code> a integer value to the location pointed by <code>q</code>. that is right. This can also lead to error at runtime if <code>q</code> is not initialized to point to right location.

blocks|key|2084634|text|在第一个语句中，您声明并初始化指向int类型值的指针(同一行)。在第二个语句中，您正在更改指针指向的值。两件不同的事。您拥有的是初始化，然后是赋值。不要让*迷惑你。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|2084635|entityMap^0|H|3|25|1|0^^$0|@$1|2|3|4|5|6|7|H|8|@$9|I|A|J|B|C]|$9|K|A|L|B|C]]|D|@]|E|$]]|$1|F|3|-4|5|6|7|M|8|@]|D|@]|E|$]]]|G|$]]

In your first statement you are declaring and initializing the pointer to some value of type <code>int</code> (on the same line). In your second statement you are changing the value pointed to by a pointer. Two different things. What you have there is initialization followed by an assignment. Don't let the <code>*</code> confuse you.

blocks|key|2123943|text|因为它不是有效的C，很简单。具体来说，它违反了赋值运算符的约束，因为整数到指针或指向整数的指针不是“简单赋值”的有效形式(C11+6.5.16.1)。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2123944|通过添加显式强制转换，可以在整数和指针之间进行转换。但是，结果不能保证工作:指针和整数可能有不同的表示，并且可能存在对齐问题。|2123945|在*q+=+6;的情况下，您将一个int分配给int，这当然是完全正确的(考虑到指针指向某个分配的内存)。|offset|length|style|CODE|2123946|entityMap^0|0|0|1|7|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|M|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|N|8|@$F|O|G|P|H|I]]|9|@]|A|$]]|$1|J|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|K|$]]

Because it is not valid C, simple as that. Specifically, it is a constraint violation of the assignment operator, since integer to pointer or pointer to integer is not valid forms of "simple assignment" (C11 6.5.16.1).

You can convert between integers and pointers by adding an explicit cast. The result is however not guaranteed to work: pointers and integers may have different representations and there might be alignment issues.

In case of <code>*q = 6;</code> you assign an int to an int, which is of course perfectly fine (given that the pointer points at allocated memory somewhere).

blocks|key|2123794|text|如果你改写成这样：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2123795|int*+q+=+8;+
++++*q+=+6;|code-block|syntax|javascript|2123796|然后您可以看到*有两个不同的用途。|offset|length|style|CODE|2123797|entityMap^0|0|0|7|1|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|@$I|R|J|S|K|L]]|9|@]|A|$]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

If you re-write it like this:

<pre><code>int* q = 8; 
 *q = 6;
</code></pre>

Then you can see the <code>*</code> has two different purposes.

blocks|key|2123990|text|试一试|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2123991|int+*q+=+new+int(8);|code-block|syntax|javascript|2123992|但是通常不需要在这里使用指针。如果必须使用指针，请使用智能指针shared_ptr<int>或uniqe_ptr<int>。|offset|length|style|CODE|2123993|entityMap^0|0|0|V|F|1B|E|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|@$I|R|J|S|K|L]|$I|T|J|U|K|L]]|9|@]|A|$]]|$1|M|3|-4|5|6|7|V|8|@]|9|@]|A|$]]]|N|$]]

Try 

<pre><code>int *q = new int(8);
</code></pre>

But working with pointers here is not normally required. If you have to use pointer, use smart pointer <code>shared_ptr&lt;int&gt;</code> or <code>uniqe_ptr&lt;int&gt;</code>.

blocks|key|2084742|text|在这种情况下，您将值8赋值给指针*q，它在初始化过程中不能工作，内存地址在那个时候是唯一的，不能分配，但是您可以在初始化后为*q设置一次内存块。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2084743|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|$]]

In this case you are assigning value 8 to pointer *q and it wont work during initialization, Memory address is unique at that time not available to assign but you can set once memory block created after initialization for *q.

error: invalid conversion from 'int' to 'int*' 
<code>int *q = 8;</code> 

Works fine. 
<code>*q = 6;</code>

Why can't I directly assign an int to an int pointer like this: <code>int *q = 6</code>; and I can assign it safely in the next line?

Why can't I directly assign an int to an int pointer like this: int *p = 6;?

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

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

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

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

文章

问答

视频

教程

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

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

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

腾讯云数据库专区

腾讯云智能顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

EdgeOne AI 安全实战专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云AI代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

功能1上新10个字符

功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符。

功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符。

功能5描述100个字符功能5描述100个字符功能5描述100个字符功能5描述100个字符功能5描述100个字符功能5描述100个字符

功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符

功能4上新

文章&问答评论现已支持表情

全新交互，全新视觉，新增快捷键、悬浮工具栏、高亮块等功能并同时优化现有功能，全面提升创作效率和体验

社区富文本编辑器全新改版！诚邀体验～ 

精选全网热门MCP server，让你的AI更好用 🚀

💥开发者 MCP广场重磅上线！

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

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

聚焦“写作效率、视觉美观与运行性能”三方面进行全面升级，为您提供更高效、稳定的创作环境

社区富文本&Markdown编辑器全新改版上线，欢迎大家体验!

诚挚邀请您参与本次调研，分享您的真实使用感受与建议。您的反馈至关重要，感谢您的支持与参与！

社区新版编辑器体验调研

错误:从“int”到“int*”的转换无效int *q = 8;效果很好。*q = 6;为什么我不能将int直接分配给像这样的int指针：int *q = 6；并且我可以在下一行中安全地分配它？

问为什么我不能直接将int赋值给这样的int指针: int *p =6？
EN

回答 13

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问为什么我不能直接将int赋值给这样的int指针: int *p =6？EN

回答 13

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问为什么我不能直接将int赋值给这样的int指针: int *p =6？
EN