标签: indirection

我们如何访问结构的变量？我有一个结构:

typedef struct {
   unsigned short a;
   unsigned shout b;
} Display;

而在我的其他课程中,我有一个方法:

int NewMethod(Display **display)
{
   Display *disp=new Display();
   *display = disp;
   disp->a=11;
}

**显示是什么意思？要访问我使用->过的struct变量,还有其他方法吗？

我最近出现了这行代码:

CustomData_em_free_block(&em->vdata, &eve->data);

我想,不是:

a->b

只是语法糖:

(*a).b

考虑到这一点,这条线可以重写为:

CustomData_em_free_block(&(*em).vdata, &(*eve).data);

如果是这样的话,传递的重点是什么

&(*a),作为参数,而不只是一个？似乎指针等效于 - ( - a)正在传入,是否有任何逻辑？

谢谢.

我是C的新手,我正在阅读指针如何"指向"另一个变量的地址.所以我尝试了间接调用和直接调用,并收到了相同的结果(正如任何C/C++开发人员所预测的那样).这就是我做的:

int cost;
int *cost_ptr;

int main()
{
    cost_ptr = &cost;                          //assign pointer to cost
    cost = 100;                                //intialize cost with a value
    printf("\nDirect Access: %d", cost);
    cost = 0;                                  //reset the value
    *cost_ptr = 100;
    printf("\nIndirect Access: %d", *cost_ptr);
    //some code here

    return 0;                                  //1
}

所以我想知道使用指针的间接调用是否比直接调用有任何优势,反之亦然？一些优点/缺点可能包括速度,执行操作所消耗的内存量(很可能相同,但我只想把它放在那里),安全性(如悬挂指针),良好的编程习惯等
^.1有趣的是,我是使用GNU C编译器(gcc),它仍然编译没有return语句,一切都按预期.也许是因为如果你忘了,C++编译器会自动插入return语句.

Delphi 2010,Win7 - 64

我正在编写一个涉及连接到不同数据库的应用程序.我使用两个不同的供应商进行数据库访问 我使用DA-Soft的AnyDAC,它允许我连接到"工业"数据库,Oracle,SQL Server等,我使用ComponentAce的ABS数据库,这是一个基于PC的小型SQL数据库.(顺便说一下,我强烈推荐).我的问题是我需要编写一系列通用例程,这些例程可能会违反供应商组件.

这两个组件都有TTable和TQuery组件.我需要编写一组例程,其中一些是基于TTable的,有些是基于TQuery的.这些例程可能违反供应商组件.

作为一个例子,我需要能够遍历TTable中的所有行.我第一次运行例程时,需要使用DA-Soft的TTable.下次运行它时,我需要它来运行Component Ace的TTable.TQuery也存在相同的情况.

我需要一层抽象 - 至少我认为我做了.我不想多次编写每个例程.建议提供这层abstration /间接的方法.我并不过分关注快速致盲.请记住 - 更简单更好,我不是一个专业的程序员....

任何想法都赞赏.感谢大家.

我想在R中的列表中插入一个元素.问题是我希望它在变量中包含一个名称.

> list(c = 2)
$c
[1] 2

说得通.我显然想要一个名为'c'的列表项,包含2.

> a <- "b"
> list(a = 1)
$a
[1] 1

哎呦.当我创建列表时,如何在需要时将R视为变量而不是名称？

我试过的一些事情:

> list(eval(a)=2)
Error: unexpected '=' in "list(eval(a)="
> list(a, 2)
[[1]]
[1] "b"

[[2]]
[1] 2
> list(get(a) = 2)
Error: unexpected '=' in "list(get(a) ="

我知道如果我已经有一个list(),我可以这样做:

> ll<-list()
> ll[[a]]=456
> ll
$b
[1] 456

...但:

> list()[[a]]=789
Error in list()[[a]] = 789 : invalid (NULL) left side of assignment

如何构造一个包含名称包含在变量中的元素的匿名列表？

我有一个看起来有点像这样的代码：

int num = 5;
int *ptr = #
void **xptr = &ptr;
printf ("values:%d\n",**(int *)xptr); 

为什么我不能取消引用指向 int 指针的 void 双指针？以下两个示例有效。

片段：1

int *ptr = #
int **xptr = &ptr;
printf ("values:%d\n",**xptr);

片段 2：

void *ptr = #
printf ("values:%d\n",*(int *)ptr);

我正在从网站上阅读C++中的哈希表实现示例,并看到了这一点.

private:
  HashEntry **table;
public:
  HashMap() {
        table = new HashEntry*[TABLE_SIZE];
        for (int i = 0; i < TABLE_SIZE; i++)
              table[i] = NULL;
  }

具有我不理解的语法的行是:

table = new HashEntry*[TABLE_SIZE];

在括号之前加上星号是什么意思？

我刚发现间接成本大约是浮点乘法的3倍!
这是预期的吗？我的考试错了吗？

背景

在我读了指针间接对效率有多大影响？,我对间接成本感到恐慌.

由于现代CPU的工作原理,通过指针间接可能要慢得多.

在我过早优化我的真实代码之前,我想确保它真的花费很多,因为我担心.

我做了一些技巧来找到粗略数字(3x),如下所示: -

步骤1

• 测试1:没有间接 - >计算一些东西
• 测试2:间接 - >计算一些东西(相同)

我发现Test2需要更多的时间来测试Test1.
这里没什么好惊讶的.

第2步

• 测试1:没有间接 - >计算一些昂贵的东西
• 测试2:间接 - >计算一些便宜的东西

我尝试将我的代码更改calculate something expensive为更加昂贵,以使两个测试成本接近相同.

结果

最后,我发现使两个测试使用相同的时间(即收支平衡)的可能功能之一是: -

• 测试1:没有间接 - >返回float*float*...3次
• 测试2:间接 - >简单地返回一个float

这是我的测试用例(ideone演示): -

class C{
    public: float hello;  
    public: float hello2s[10];  
    public: C(){
        hello=((double) rand() / (RAND_MAX))*10;
        for(int n=0;n<10;n++){
            hello2s[n]= ((double) rand() / (RAND_MAX))*10; …

鉴于:

#include <iostream>
#include <functional>

template<class T> // Just for overloading purposes
struct behaviour1 : std::reference_wrapper<T const>
{
    using base_t = std::reference_wrapper<T const>;
    using base_t::base_t;

    // This wrapper will never outlive the temporary
    // if used correctly
    behaviour1(T&& t) : base_t(t) {}
};

template<class T>
behaviour1(T&&) -> behaviour1<std::decay_t<T> >;

struct os_wrapper : std::reference_wrapper<std::ostream>
{
    using std::reference_wrapper<std::ostream>::reference_wrapper;

    template<class T>
    os_wrapper& operator<<(behaviour1<T> const& v)
    {
        *this << v.get(); // #1
        return *this;
    }

    template<class U>
    os_wrapper& operator<<(U&& t)
    { this->get() << t; …

我有以下代码:

#include <iostream>

struct Base {
    int i_;
};

class El : protected Base {
public:
    int get_i() const { return i_; }
    void set_i(int i) { i_ = i; }
};

class It : protected Base {
public:
    using pointer = const El*;
    using reference = const El&;

    reference operator*() const
    {
        return reinterpret_cast<reference>(*this);
    }

    pointer operator->() const
    {
        return reinterpret_cast<pointer>(this);
    }
};

int main()
{
    It it;
    It* itp = &it;
    std::cout << *****(itp)->get_i() << "\n"; //ERROR
} …

我想编写一个函数，该函数采用数组变量名称并更新内容。例如：

ARRAY1=("test 1" "test 2" "test 3")
toUpper ARRAY1

for arg in "${ARRAY1[@]}"; do
  echo "arg=$arg"
done

# output
arg=TEST 1
arg=TEST 2
arg=TEST 3

我有一个粗略的尝试，这需要输入数组的副本。使用间接引用，我能够创建输入变量的副本。数组的副本用于获取元素的计数。如果有更好的方法来做到这一点，请告诉我。

function toUpper() {
  local ARRAY_NAME=$1
  local ARRAY_REF="$ARRAY_NAME[@]"
  # use an indirect reference to copy the array so we can get the count
  declare -a ARRAY=("${!ARRAY_REF}")

  local COUNT=${#ARRAY[@]}

  for ((i=0; i<$COUNT; i++)); do
    local VAL="${ARRAY[$i]}"
    VAL=$(echo $VAL | tr [:lower:] [:upper:])
    echo "ARRAY[$i]=\"$VAL\""
    eval "$ARRAY_NAME[$i]=\"$VAL\""
  done
}

ARRAY1=( "test" "test 1" "test 3" )

toUpper …