Question

我正在研究指针和参考部分，并且很难研究它们。我想我现在理解了函数中引用和指针的一些简单用法，但有些东西我无法完全理解。

以下是一些变量声明：

int a = 1;
float b = 2;
int* p = &a;
string s = "Hello";
vector<int*> values = {p};

以下表达式的类型是什么？

&a
&b
p
&p
&s
&(s.at(1))
values.at(0)
&(values.at(0))
&values

我不知道他们的类型究竟是什么，但我自己尝试过。

&a : pointer to int
&b : pointer float
 p : pointer to int
&p : pointer to pointer to int
&s : pointer to string
&(s.at(1)) : pointer to string
values.at(0) : pointer to int
&(values.at(0)) : pointer to pointer to int
&values : pointer to pointer to int

还有一个问题＆gt; 编写以下变量声明： a）指向字符串的指针 b）对浮子的引用 c）一组指向内的指针。 d）指向bool指针的指针 e）对指向int

的指针的引用

我的答案是：

a: string* s = "Hello"

b: float& f = g;

c: int n =1;
   int*x =&n;
   int arr[] = {*x};

d: bool y = true;
   bool* x = &y;
   bool** qq = &x;

e: int a = 1;
   int* x = &a;
   int& z = *x;

我不确定我的答案。请帮助这些令人困惑的部分。

Answer 1

第1部分：

如果表达式e的类型为T，则&e的类型为pointer to T; T*。
s.at(1)和values的类型。

第2部分：

c：int arr[]不是＆＃34;指向＆lt; 34;＆＃34;＆＃34;＆＃34;数组int＆＃34;。
T的数组是T arr[]; int*的数组是int* arr[]。

int n = 1;
int* arr[] = {&n};

e：int& z不是＆＃34;指向int＆＃34;的指针，它是＆＃34;对int＆＃34的引用34 ;.
对T的引用是T&;对int*的引用是int*&。

int a = 1;
int* x = &a;
int*& z = x;

Answer 2

如果您需要知道表达式的确切类型以及是否可以使用Boost，它可以提供强大的功能。

#include <boost/type_index.hpp>
#include <iostream>
#include <string>
#include <vector>

#define TYPE(x) std::cout << "decltype(" << #x << ") == " << type_id_with_cvr<decltype(x)>().pretty_name() << std::endl

int main()
{
    using boost::typeindex::type_id_with_cvr;

    int a;
    TYPE(a);

    int * p = &a;
    TYPE(p);
    TYPE(&p);

    std::vector<int*> values {p};
    TYPE(values.at(0));
    TYPE(&(values.at(0)));
    TYPE(&values);
}

如果你不能使用Boost，你仍然可以故意创建一个模板错误，迫使编译器向你展示表达式的类型（来自Scott Meyers，一位伟大的C ++专家）。

#include <iostream>
#include <string>
#include <vector>

template <typename T>
    class TD;

template <typename T>
void function(T & param)
{
    TD<T> templateType;
    TD<decltype(param)> paramType;
}

int main()
{
    int a;
    function(a);

    int * p = &a;
    function(p);
    function(&p);

    std::vector<int*> values {p};
    function(&values);
}

c）指向内部的指针数组

您创建了一个int数组，其中包含一个值，即希望指针引用的值。如前所述，您需要一个int* []数组。

Answer 3

首先，std::string是一个包含char数组的复杂对象，但它绝对不是char数组。而std::vector<int>也是一个包含一组int的复杂对象。

这意味着，对于第一部分，您的一些尝试是错误的：

&(s.at(1)) : pointer to string               WRONG: pointer to char
values.at(0) : pointer to int                OK
&(values.at(0)) : pointer to pointer to int  OK
&values : pointer to pointer to int          WRONG: pointer to `vector<int>`

对于第二部分，由于字符串不是char数组，因此无法使用litteral char数组初始化指向字符串的指针

string *s = "hello";   WRONG syntax error

您必须首先创建一个字符串，然后创建一个指向它的指针

string s = "hello";   OK std::string initialized from a const char *
string *ps = &s;      OK pointer to std::string

c也是错误的int arr[]声明了一个int数组。你必须写：

int *arr[] = { x };  OK array of 1 pointers initialized from x which is a pointer to int

对于e，int&z = *x;声明对int初始化为ref的引用。要获得指针的引用，您必须写：

int *&z = x;   OK ref to a pointer to int initialized as a ref to x

Answer 4

＆amp;（values.at（0））：指向int的指针

为什么＆amp;（values.at（0））是指针？

指针是包含内存中地址的变量指针有类型

    unsigned long ip = 0xC0A80A01;  // 192.168.10.1
    unsigned char *p = (unsigned char *)&ip;
    printf("%d.%d.%d.%d\n", p[3], p[2], p[1], p[0]); 
    // Result: 192.168.10.1

我认为只需要变量的地址。

int a = 1;
int *p = &a; 
&a is not a pointer
p is a pointer

是吗？

和
int＆amp; refVar = a; refVar是参考

参考＆amp;指针混淆部分（声明及其类型）

4 个答案: