blocks|key|2364988|text|因为指针是一个变量，它的值是一个入口，那么*操作符就可以访问指向的入口的值。例子：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2364989|char+*str+=+new+char[20];|offset|length|style|CODE|2364990|str是一个指针，因此它具有：|2364991|_a+&str+=+adress1+_a值str+=+adress2+(因为它是指针)|2364992|在这个adress2中有20个字符是连续的，所以第一个字符在adress2中，然后是adress2%2B1，然后是adress2%2B2等等。|2364993|entityMap^0|0|0|P|0|0|3|E|L|D|0|0^^$0|@$1|2|3|4|5|6|7|P|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|Q|8|@$D|R|E|S|F|G]]|9|@]|A|$]]|$1|H|3|I|5|6|7|T|8|@]|9|@]|A|$]]|$1|J|3|K|5|6|7|U|8|@$D|V|E|W|F|G]|$D|X|E|Y|F|G]]|9|@]|A|$]]|$1|L|3|M|5|6|7|Z|8|@]|9|@]|A|$]]|$1|N|3|-4|5|6|7|10|8|@]|9|@]|A|$]]]|O|$]]

Cause a pointer is a variable who's value is an adress, the value of the adress pointed is then accessible by the * operator.
example :
<code>char *str = new char[20];</code>
str is a pointer so it has :
_ an adress <code>&amp;str = adress1</code>
_ a value <code>str = adress2</code> (it's adress because it's a pointer)
And at this adress2 are 20 character on continuous adress, so first character would be in adress adress2, then next one adress2+1, then adress2+2 etc..

blocks|key|1152927|text|假设在项目1中出现了语法错误。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1152928|1152929|str是指向字符的指针，但在本例中，它指向此类数组中的第一个指针。*str是对单个字符(字节)的引用。指针可以通过传递数组开头的地址来传递字符串。我们保证能够增加该指针并取消引用它，以便访问以下字符|ordered-list-item|offset|length|style|CODE|1152930|1152931|这就是strlen的工作方式：|1152932|++size_t+strlen(char+*p)
++{
++++size_t+len+=+0;
++++while+(*p%2B%2B+!=+0)+len+%2B%2B;
++++return+len;
++}|code-block|syntax|javascript|1152933|1152934|p是指针到int的值，写到它没有任何意义。int.|1152935|类型的数组的第一个元素引用*p|1152936|entityMap^0|0|0|0|3|X|4|0|0|3|6|0|0|0|0|1|L|3|0|D|2|0^^$0|@$1|2|3|4|5|6|7|Y|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|Z|8|@]|9|@]|A|$]]|$1|C|3|D|5|E|7|10|8|@$F|11|G|12|H|I]|$F|13|G|14|H|I]]|9|@]|A|$]]|$1|J|3|-4|5|6|7|15|8|@]|9|@]|A|$]]|$1|K|3|L|5|6|7|16|8|@$F|17|G|18|H|I]]|9|@]|A|$]]|$1|M|3|N|5|O|7|19|8|@]|9|@]|A|$P|Q]]|$1|R|3|-4|5|6|7|1A|8|@]|9|@]|A|$]]|$1|S|3|T|5|E|7|1B|8|@$F|1C|G|1D|H|I]|$F|1E|G|1F|H|I]]|9|@]|A|$]]|$1|U|3|V|5|6|7|1G|8|@$F|1H|G|1I|H|I]]|9|@]|A|$]]|$1|W|3|-4|5|6|7|1J|8|@]|9|@]|A|$]]]|X|$]]

Assuming that there was a grammar mishap in bullet 1.
<ol>
<li><code>str</code> is a pointer to a char but in this case it point to first one in an array of such. <code>*str</code> is a reference to single char (byte). pointers can be used to pass string by passing address of array's beginning. We are guaranteed to be able to increment that pointer and dereference it in order to access following characters</li>
</ol>
E.g. this is how <code>strlen</code> may work:
<pre><code> size_t strlen(char *p)
 {
 size_t len = 0;
 while (*p++ != 0) len ++;
 return len;
 }
</code></pre>
<ol start="2">
<li><code>p</code> is value of pointer to int, there is no meaning in writing to it. <code>*p</code> is reference to first element of array, of type <code>int</code>.</li>
</ol>

blocks|key|1145975|text|操作符重载<<和>>分别对const+char*和char*具有特殊的重载，因为它们是以空结尾的C样式字符串。与其他指针/其他数组相比，它们被区别对待。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1145976|下面是对所使用的语义的一些比较：|1145977|cin+>>+str;|code-block|syntax|javascript|1145978|意思是“将一个以空结尾的字符串读入数组，其中str是指向第一个元素的指针”。|1145979|cout+<<+str;+|1145980|意思是“打印一个以空结尾的字符串，其中str是指向第一个元素的指针”。|1145981|1145982|但是，对于其他指针类型，比如int*，也有这样的语义。|1145983|cin+>>+p;|1145984|不行，没有“读取一个ints数组”或“读取一个指针”之类的东西。|1145985|cin+>>+*p;+|1145986|工作并表示“读取单个整数并将其存储在p值中”，即数组get中的第一个元素的修改。|1145987|cout+<<+p;|1145988|意思是“打印指针的值”，因为int*没有特殊的语义，比如“ints的打印数组”。另一方面，|1145989|cout+<<+*p;|1145990|意思是“打印一个整数，即p的值”，即数组中的第一个元素被打印出来。|1145991|entityMap^0|5|2|8|2|D|B|P|5|0|0|0|M|3|0|0|J|3|0|0|E|4|0|0|0|0|I|1|0|0|E|4|0|0|C|1|0^^$0|@$1|2|3|4|5|6|7|1D|8|@$9|1E|A|1F|B|C]|$9|1G|A|1H|B|C]|$9|1I|A|1J|B|C]|$9|1K|A|1L|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|1M|8|@]|D|@]|E|$]]|$1|H|3|I|5|J|7|1N|8|@]|D|@]|E|$K|L]]|$1|M|3|N|5|6|7|1O|8|@$9|1P|A|1Q|B|C]]|D|@]|E|$]]|$1|O|3|P|5|J|7|1R|8|@]|D|@]|E|$K|L]]|$1|Q|3|R|5|6|7|1S|8|@$9|1T|A|1U|B|C]]|D|@]|E|$]]|$1|S|3|-4|5|6|7|1V|8|@]|D|@]|E|$]]|$1|T|3|U|5|6|7|1W|8|@$9|1X|A|1Y|B|C]]|D|@]|E|$]]|$1|V|3|W|5|J|7|1Z|8|@]|D|@]|E|$K|L]]|$1|X|3|Y|5|6|7|20|8|@]|D|@]|E|$]]|$1|Z|3|10|5|J|7|21|8|@]|D|@]|E|$K|L]]|$1|11|3|12|5|6|7|22|8|@$9|23|A|24|B|C]]|D|@]|E|$]]|$1|13|3|14|5|J|7|25|8|@]|D|@]|E|$K|L]]|$1|15|3|16|5|6|7|26|8|@$9|27|A|28|B|C]]|D|@]|E|$]]|$1|17|3|18|5|J|7|29|8|@]|D|@]|E|$K|L]]|$1|19|3|1A|5|6|7|2A|8|@$9|2B|A|2C|B|C]]|D|@]|E|$]]|$1|1B|3|-4|5|6|7|2D|8|@]|D|@]|E|$]]]|1C|$]]

The operator overloads <code>&lt;&lt;</code> and <code>&gt;&gt;</code> have special overloads for <code>const char*</code> and <code>char*</code> respectively, because those are null-terminated C-style strings. They are
treated diifferently than other pointers/other arrays.
Here's a little comparison of the semantics used:
<pre><code>cin &gt;&gt; str;
</code></pre>
means &quot;read a null terminated string into an array, where <code>str</code> is the pointer to the first element&quot;.
<pre><code>cout &lt;&lt; str; 
</code></pre>
means &quot;Print a null terminated string, where <code>str</code> is the pointer to the first element&quot;.
<hr>
However there are such semantics for other pointer types like <code>int*</code>.
<pre><code>cin &gt;&gt; p;
</code></pre>
wont work, there is no such thing as &quot;reading an array of ints&quot;, or &quot;reading a pointer&quot;, while
<pre><code>cin &gt;&gt; *p; 
</code></pre>
works and means &quot;read a single integer and store it in the value of <code>p</code>&quot;, that is, the first element in the array get's modified.
<pre><code>cout &lt;&lt; p;
</code></pre>
means &quot;print the value of the pointer&quot;, again, because there are no special semantics for <code>int*</code> like &quot;Print array of ints&quot;. On the other hand
<pre><code>cout &lt;&lt; *p;
</code></pre>
meanse &quot;Print one integer, that is the value of <code>p</code>&quot;, that is, the first element in the array get's printed.

blocks|key|1152980|text|char*+str+=+new+char[20];
cin>>str;|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1152981|您将指针传递到一系列char到cin，因为cin需要在指针指向的位置读取多个字符。|unstyled|offset|length|style|CODE|1152982|int*+p+=+new+int[3];
cin>>*p;|1152983|通过引用将单个int传递给cin，因为cin需要读取单个int。没有读取功能可以读取一系列int，因为int序列不是通常的事情。然而，一个字符序列是一个c-字符串和一个典型的事物.这就是为什么cin有一个读取字符指针的重载。|1152984|entityMap^0|0|F|3|L|3|0|0|D|3|J|3|2O|3|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|R|8|@$G|S|H|T|I|J]|$G|U|H|V|I|J]]|9|@]|A|$]]|$1|K|3|L|5|6|7|W|8|@]|9|@]|A|$B|C]]|$1|M|3|N|5|F|7|X|8|@$G|Y|H|Z|I|J]|$G|10|H|11|I|J]|$G|12|H|13|I|J]]|9|@]|A|$]]|$1|O|3|-4|5|F|7|14|8|@]|9|@]|A|$]]]|P|$]]

<pre><code>char* str = new char[20];
cin&gt;&gt;str;
</code></pre>
You are passing the pointer to a series of char to <code>cin</code> because <code>cin</code> is expected to read multiple chars at the location pointed to by the pointer.
<pre><code>int* p = new int[3];
cin&gt;&gt;*p;
</code></pre>
You are passing a single int, by reference, to <code>cin</code>, because <code>cin</code> is expected to read a single int. There is no read functionality that will read a sequence of ints, because a sequence of int is not an usual thing. However, a sequence of char is a c-string and a typical thing. That's why <code>cin</code> has an overload that reads to a char pointer.

blocks|key|1490337|text|最好重写这个代码片段。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1490338|int*+p+=+new+int[3];
cin>>*p;
cout<<*p<<endl;
delete+[]p;|code-block|syntax|javascript|1490339|喜欢|1490340|int*+p+=+new+int;
cin>>*p;
cout<<*p<<endl;
delete+p;|1490341|因为只使用了分配的数组中的一个对象，该数组包含三个int类型的对象。|1490342|在第一种情况下，您处理的是接受或存储字符串的字符数组。例如，对于字符数组，操作符>>声明如下|1490343|template<class+charT,+class+traits>
basic_istream<charT,traits>&+operator>>(basic_istream<charT,traits>&,
charT*);|1490344|也就是说，运算符不仅需要访问数组的第一个字符，还需要使用指针算法访问数组的后续字符。运算符不更改传递的指针。它更改指针所指向的类型字符的对象。|1490345|对于int类型的对象，操作符>>声明如下|1490346|basic_istream<charT,traits>&+operator>>(int&+n);|1490347|通过引用传递一个标量对象就足以使用操作符来更改它。|1490348|entityMap^0|0|0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|10|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|11|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|12|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|13|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|14|8|@]|9|@]|A|$]]|$1|M|3|N|5|6|7|15|8|@]|9|@]|A|$]]|$1|O|3|P|5|D|7|16|8|@]|9|@]|A|$E|F]]|$1|Q|3|R|5|6|7|17|8|@]|9|@]|A|$]]|$1|S|3|T|5|6|7|18|8|@]|9|@]|A|$]]|$1|U|3|V|5|D|7|19|8|@]|9|@]|A|$E|F]]|$1|W|3|X|5|6|7|1A|8|@]|9|@]|A|$]]|$1|Y|3|-4|5|6|7|1B|8|@]|9|@]|A|$]]]|Z|$]]

It is better to rewrite this code snippet
<pre><code>int* p = new int[3];
cin&gt;&gt;*p;
cout&lt;&lt;*p&lt;&lt;endl;
delete []p;
</code></pre>
like
<pre><code>int* p = new int;
cin&gt;&gt;*p;
cout&lt;&lt;*p&lt;&lt;endl;
delete p;
</code></pre>
because there is used only one object of the allocated array of three objects of the type int.
In the first case you are dealing with a character array that accepts or stores a string. For character arrays for example the operator &gt;&gt; is declared like
<pre><code>template&lt;class charT, class traits&gt;
basic_istream&lt;charT,traits&gt;&amp; operator&gt;&gt;(basic_istream&lt;charT,traits&gt;&amp;,
charT*);
</code></pre>
That is the operator needs to get access not only to the first character of the array but also to subsequent characters of the array using the pointer arithmetic. The operator does not change the passed pointer. It changes the objects of the type character pointed to by the pointer.
For objects of the type int the operator &gt;&gt; is declared like
<pre><code>basic_istream&lt;charT,traits&gt;&amp; operator&gt;&gt;(int&amp; n);
</code></pre>
It is enough to pass a scalar object by reference to change it using the operator.

<code>str</code> is a pointer, why not use <code>str</code> for input and output? Not <code>*str</code>. 
 <code>p</code> is a pointer, why use <code>*p</code> for input and output? Not <code>p</code>.
<pre class="lang-cpp prettyprint-override"><code>#include&lt;iostream&gt;
using namespace std;

int main()
{
 
 char* str = new char[20];
 cin&gt;&gt;str;
 cout&lt;&lt;str&lt;&lt;endl;
 delete []str;

 int* p = new int[3];
 cin&gt;&gt;*p;
 cout&lt;&lt;*p&lt;&lt;endl;
 delete []p;

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

C++ dynamic memory allocation (char[] and int[])

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

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

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

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

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

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

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

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

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

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

str是一个指针，为什么不使用str作为输入和输出？不是*str。p是一个指针，为什么使用*p作为输入和输出？不是p。#include<iostream>using namespace std;int main(){ char* str = new char[20]; cin>>str; cou...

问C++动态内存分配(char[]和int[])
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问C++动态内存分配(char[]和int[])EN