javascript

java

python

c#

node.js

android

reactjs

c++

php

jquery

html

css

git

ruby-on-rails

.net

ios

sql

c

string

ruby

为什么C ++ 11包含一个关于比较void指针的奇数子句?

在检查引用的另一个问题时,我注意到C ++ 11的[expr.rel]¶3中有一个奇数子句:

可以比较指向void的指针(在指针转换之后),其结果定义如下:如果两者   指针表示相同的地址或均为空指针值,如果运算符为,则结果为a   bvoid *void *否则; 否则结果不确定。

这似乎意味着,一旦将两个指针强制转换为a,就不再保证它们的顺序关系。 例如,这:

int foo[] = {1, 2, 3, 4, 5};
void *a = &foo[0];
void *b = &foo[1];
std::cout<<(a < b);

似乎未指定。

有趣的是,该子句在C ++ 03中不存在,而在C ++ 14中消失了,因此,如果我们以上述示例为例,并对其应用C ++ 14措辞,我会说¶3.1

  • 如果两个指针指向同一数组的不同元素或其子对象,则下标较高的元素的指针比较大。

将适用,因为ab指向同一数组的元素,即使它们已强制转换为void *。请注意,¶3.1的措词在C ++ 11中几乎相同,但似乎被C ++ 11覆盖了。 void *条款。

我的理解正确吗? 在C ++ 11中添加并立即删除的那个奇数子句的意义是什么? 还是它仍然存在,但移至标准的其他部分/暗示了该标准?

trans by 2019-10-11T21:47:19Z

c-在功能名称前加星号的功能是什么?

我对在大多数C程序中看到的对我来说不熟悉的函数声明感到困惑。

void *func_name(void *param){
    ...
}

*对该功能意味着什么? 我对(*)变量类型的理解是,它创建了一个指向另一个变量的指针,因此它可以跟踪将哪个变量存储在内存中的地址。 但是在这种情况下,我不知道这个*星号的含义。

trans by 2019-10-10T08:29:30Z

c-空指针和空指针有什么区别?

空指针和空指针之间有什么区别?

trans by 2019-10-09T18:40:20Z

在C ++中返回指向矢量元素的指针

我在全局范围内有一个myObjects向量。我有一种使用std::vector<myObject>::const_iterator遍历向量的方法,并进行了一些比较以查找特定的元素。找到所需元素后,我希望能够返回一个指向它的指针(向量存在于全局范围内)。

如果我返回const_iterator,是返回迭代器的地址还是迭代器指向的地址?

我是否需要将2561740731522222221056强制转换回myObject,然后返回其地址?

trans by 2019-10-09T13:56:11Z

在Go HTTP处理程序中,为什么ResponseWriter是一个值,而Request是一个指针?

我正在通过为GAE编写应用来学习Go,这是处理程序函数的签名:

func handle(w http.ResponseWriter, r *http.Request) {}

我在这里是新手指针,所以为什么Request对象是指针,而ResponseWriter不是? 是否有必要采用这种方式,还是只是为了使某种基于高级指针的代码成为可能?

trans by 2019-10-07T11:49:57Z

c ++-“ int * p = + s”是什么? 做?

我在这里看到了一种奇怪的程序。

int main()
{
    int s[]={3,6,9,12,18};
    int* p=+s;
}

上面的程序在GCC和Clang编译器上进行了测试,并且在两个编译器上都可以正常工作。

我很好奇,s是做什么的?

数组2556780233659759778048是否衰减为指针类型?

trans by 2019-10-06T03:48:28Z

声明in的数组

这两个声明之间有什么区别吗?

int x[10];

int* x = new int[10];

我假设前一个声明(与后一个声明一样)是指针声明,并且两个变量可以被视为相同。 这是否意味着它们本质上是相同的?

trans by 2019-10-04T11:26:49Z

C vs C ++结构对齐

在最近的一次采访中,有人问我有关C ++结构字段对齐的问题,并认为C和C ++在结构打包方面遵循相同的策略。

专家,这是错误的假设。 采访者说,一般而言,C和C ++以不同的方式打包结构,我们绝不能指望相反。 恕我直言,这是一个奇怪的说法。 C ++中没有可在双语C / C ++头文件中使用的结构的pack "C"限定符。

因此,在实践中,这可能意味着您无法在C ++中创建结构并将其传递给C库,因为一般而言,其字段将以不同的方式对齐并具有不同的偏移量。 但是,实际上,大多数程序员严重依赖于这种互操作性,直到他们使用一些辅助方法将指向C POD结构的指针转换为对该结构周围的C ++包装器的引用时为止。 您能澄清一下这件事吗?

trans by 2019-10-03T23:45:23Z

C字符串中'\ 0'之后的内存会如何处理?

出乎意料的简单/愚蠢/基本问题,但我不知道:假设我想向函数用户返回一个C字符串,该字符串的长度在函数开始时不知道。 一开始我只能在长度上设置一个上限,并且根据处理的不同,大小可能会缩小。

问题是,分配足够的堆空间(上限),然后在处理过程中终止字符串不足的地方,这有什么问题吗? 即,如果我在分配的内存中间插入一个'\ 0',(a。)free()是否仍然可以正常工作,并且(b。)'\ 0'之后的空格是否变得无关紧要? 添加“ \ 0”后,是否只是返回了内存,还是在内存中占用了空间直到调用free()? 为了节省一些前期的编程时间来在调用malloc之前计算必要的空间,将这种悬挂空间留在那里通常是不好的编程风格吗?

为了提供一些背景信息,假设我要删除连续的重复项,如下所示:

输入“你好,哦!” ->输出“ Helo oOo!”

...和下面的一些代码显示了我如何预先计算操作所产生的大小,有效地执行了两次处理以使堆大小正确。

char* RemoveChains(const char* str)
{
    if (str == NULL) {
        return NULL;
    }
    if (strlen(str) == 0) {
        char* outstr = (char*)malloc(1);
        *outstr = '\0';
        return outstr;
    }
    const char* original = str; // for reuse
    char prev = *str++;       // [prev][str][str+1]...
    unsigned int outlen = 1;  // first char auto-counted

    // Determine length necessary by mimicking processing
    while (*str) {
        if (*str != prev) { // new char encountered
            ++outlen;
            prev = *str; // restart chain
        }
        ++str; // step pointer along input
    }

    // Declare new string to be perfect size
    char* outstr = (char*)malloc(outlen + 1);
    outstr[outlen] = '\0';
    outstr[0] = original[0];
    outlen = 1;

    // Construct output
    prev = *original++;
    while (*original) {
        if (*original != prev) {
            outstr[outlen++] = *original;
            prev = *original;
        }
        ++original;
    }
    return outstr;
}
trans by 2019-10-03T18:59:59Z

为什么在C和C ++中对NULL指针的定义不同?

在C中,将NULL定义为(void *)0,而在C ++中将其定义为0。为什么会这样?在C语言中,我可以理解,如果NULL未类型转换为(void *),则编译器可能会/可能不会生成警告。 除此之外,还有什么原因吗?

trans by 2019-09-26T09:59:01Z

c-如何增加指针地址和指针的值?

让我们假设

int *p;
int a = 100;
p = &a;

以下代码将实际执行什么操作以及如何执行?

p++;
++p;
++*p;
++(*p);
++*(p);
*p++;
(*p)++;
*(p)++;
*++p;
*(++p);

我知道,这在编码方面有点麻烦,但是我想知道当我们像这样编码时实际会发生什么。

注意:假设地址a=5120300存储在指针p中,其地址为3560200。现在,执行每个语句后p & a的值是什么?

trans by 2019-09-25T10:39:30Z

功能-Golang中的值接收器与指针接收器?

对于我来说,目前尚不清楚,在这种情况下,我想使用值接收器而不是始终使用指针接收器。
回顾一下文档:

type T struct {
    a int
}
func (tv  T) Mv(a int) int         { return 0 }  // value receiver
func (tp *T) Mp(f float32) float32 { return 1 }  // pointer receiver

该文档还说:“对于基本类型,切片和小型结构之类的类型,值接收器非常便宜,因此,除非该方法的语义要求使用指针,否则值接收器将是高效且清晰的。”

首先,它说“非常便宜”,但问题是它比指针接收器便宜。 因此,我做了一个小的基准测试(基于要点的代码),向我展示了,即使对于只有一个字符串字段的结构,指针接收器也更快。 结果如下:

// Struct one empty string property
BenchmarkChangePointerReceiver  2000000000               0.36 ns/op
BenchmarkChangeItValueReceiver  500000000                3.62 ns/op


// Struct one zero int property
BenchmarkChangePointerReceiver  2000000000               0.36 ns/op
BenchmarkChangeItValueReceiver  2000000000               0.36 ns/op

(编辑:请注意,第二点在较新的go版本中变得无效,请参阅注释)。
第二点说,这是“高效而清晰的”,更多的是品味问题,不是吗? 就个人而言,我更喜欢在各处使用相同的方式来保持一致性。 效率在什么意义上? 在性能方面似乎指针几乎总是更高效。 具有int属性的测试很少显示Value接收器的最小优势(范围为0.01-0.1 ns / op)

有人可以告诉我一个值接收器比指针接收器更有意义的情况吗? 还是我在基准测试中做错了什么,我是否忽略了其他因素?

trans by 2019-09-23T19:13:11Z

c ++-错误:从类型为'int'的右值无效初始化了'int&'类型的非常量引用

格式错误:

int &z = 12;

正确形式:

int y;
int &r = y;

题:
为什么第一个代码错误? 标题错误的“含义”是什么?

trans by 2019-09-22T12:19:10Z

c-指针与普通指针的对比

指针的目的是保存特定变量的地址。 然后,以下代码的内存结构应类似于:

int a = 5;
int *b = &a;

......内存地址......值
一个... 0x000002 ................... 5
b ... 0x000010 ................... 0x000002

好的。 然后假设现在我要保存指针* b的地址。 然后,我们通常将双指针** c定义为

int a = 5;
int *b = &a;
int **c = &b;

然后,内存结构如下所示:

......内存地址......值
一个... 0x000002 ................... 5
b ... 0x000010 ................... 0x000002
c ... 0x000020 ................... 0x000010

因此,** c表示* b的地址。

现在我的问题是,为什么要使用这种类型的代码,

int a = 5;
int *b = &a;
int *c = &b;

产生警告?

如果指针的目的只是保存内存地址,我想如果要保存的地址是变量,指针,双指针等,则应该没有层次结构,因此以下类型的代码应该 有效。

int a = 5;
int *b = &a;
int *c = &b;
int *d = &c;
int *e = &d;
int *f = &e;
trans by 2019-09-22T09:32:59Z

.net-C#中的引用类型

考虑以下代码:

public class Program
{
    private static void Main(string[] args)
    {
        var person1 = new Person { Name = "Test" };
        Console.WriteLine(person1.Name);

        Person person2 = person1;
        person2.Name = "Shahrooz";
        Console.WriteLine(person1.Name); //Output: Shahrooz
        person2 = null;
        Console.WriteLine(person1.Name); //Output: Shahrooz
    }
}

public class Person
{
    public string Name { get; set; }
}

显然,当将person2 = null分配给person1person2Name属性被更改时,person1Name也将被更改。 person1person2具有相同的引用。

为什么当person2 = nullperson1变量也不为空?

trans by 2019-09-19T23:49:46Z

c ++ - 函数指针的重点是什么?

我很难看到函数指针的实用程序。 我想它在某些情况下可能是有用的(毕竟它们存在),但我想不出使用函数指针更好或不可避免的情况。

你能举出一些好用函数指针的例子(在C或C ++中)吗?

trans by 2019-09-16T20:19:49Z

c ++ - 我可以将“字节数”设置为零的memcpy()和memmove()调用吗?

作为边缘案例,当我无法移动/复制memmove()/memcpy()时,是否需要处理案件?

int numberOfBytes = ...
if( numberOfBytes != 0 ) {
    memmove( dest, source, numberOfBytes );
}

或者我应该在没有检查的情况下调用该函数

int numberOfBytes = ...
memmove( dest, source, numberOfBytes );

是否需要检查前片段?

trans by 2019-09-16T17:31:06Z

是否可以将C指针初始化为NULL?

我一直在写类似的东西

char *x=NULL;

假设是

 char *x=2;

会创建一个指向地址2的char指针。

但是,在GNU C编程教程中,它说char *x=NULL将整数值NULL存储到分配时的char中的任意随机地址。

这似乎意味着我自己的char *x=NULL正在分配任何NULL投射到char的值是内存中的某个随机地址。

#include <stdlib.h>
#include <stdio.h>

int main()
{
    char *x=NULL;

    if (x==NULL)
        printf("is NULL\n");

    return EXIT_SUCCESS;
}

事实上,印刷品

一片空白

当我编译并运行它时,我担心我依赖于未定义的行为,或者至少是指定不足的行为,我应该写

char *x;
x=NULL;

代替。

trans by 2019-09-12T18:04:20Z

c ++ - “int * ptr = int()”值初始化如何不违法?

以下代码(取自此处):

int* ptr = int();

在Visual C ++中编译并对指针进行值初始化。

怎么可能? 我的意思是int()产生类型为int的对象,我不能将int分配给指针。

上面的代码如何不违法?

trans by 2019-09-10T06:09:02Z

c ++ - int(*)(int *)= 5(或任何整数值)的含义

我无法弄清楚这一点:

int main() {
    int (*) (int *) = 5;
    return 0;
}

上面的赋值用g ++ c ++ 11编译。 我知道my_ptr是一个指向函数的指针,该函数接受int *作为参数并返回一个int,但我不明白你怎么能把它等同于5.起初我认为它是一个不断返回5的函数(来自我最近 在F#学习,可能,哈哈),然后我简单地想,函数指针指向内存位置5,但这显然不起作用,十六进制值也没有。

认为这可能是因为函数返回一个int,并且分配一个int是好的(不知何故),我也试过这个:

int * (*) (int *) = my_ptr

其中my_ptr的类型为int *,与第二个函数指针的类型相同,如第一种类型为int的情况。 这不编译。 分配5或任何int值而不是my_ptr也不会为此函数指针编译。

那么作业是什么意思呢?

更新1

我们已经确认这是一个错误,如最佳答案所示。 但是,仍然不知道您分配给函数指针的值实际发生了什么,或者赋值的情况。 任何(好的)解释都将非常感谢! 有关问题的详细说明,请参阅下面的编辑。

编辑1

我使用的是gcc版本4.8.2(在Ubuntu 4.8.2中)

编辑2

实际上,将它等同于我的编译器。 甚至将它等同于std :: string变量,或者返回double的函数名,也可以。

编辑2.1

有趣的是,使它成为一个函数指针,指向任何返回不是指针的数据类型的函数,将让它进行编译,例如

std::string (*) () = 5.6;

但是只要函数指针指向返回某个指针的函数,它就不会编译,例如with

some_data_type ** (*) () = any_value;
trans by 2019-09-09T23:00:07Z

1 2 3 4 5 6 下一页 共6页