表达式查找包含整数数组中所有元素的所有对象
，可以通过以下步骤来实现：
- 遍历整数数组，逐个元素进行判断。
- 对于每个元素，可以使用条件语句来判断是否满足查找条件。
- 如果满足条件，将该元素所在的对象添加到结果集中。
- 最后返回结果集，其中包含了所有满足条件的对象。
以下是一个示例代码，用于实现上述功能：
def find_objects_with_integer(arr, objects):
result = []
for obj in objects:
for key, value in obj.items():
if isinstance(value, list) and set(arr).issubset(set(value)):
result.append(obj)
break
return result在这个示例代码中，arr 是整数数组，objects 是包含多个对象的列表。函数 find_objects_with_integer 遍历了每个对象，并检查对象中的每个键值对。如果某个键对应的值是一个整数数组，并且该数组包含了 arr 中的所有元素，那么该对象就满足条件，会被添加到结果集 result 中。
这个函数可以适用于各种场景，例如在一个电商网站中，可以使用该函数查找包含指定商品编号的所有订单对象。
腾讯云相关产品和产品介绍链接地址：
- 云服务器（CVM）：提供弹性计算能力，可根据业务需求灵活调整配置。产品介绍链接
- 云数据库 MySQL 版（CDB）：提供稳定可靠的关系型数据库服务，适用于各种应用场景。产品介绍链接
- 人工智能机器学习平台（AI Lab）：提供丰富的人工智能算法和模型，帮助开发者快速构建智能应用。产品介绍链接
- 云存储（COS）：提供安全可靠的对象存储服务，适用于海量数据的存储和访问。产品介绍链接
- 区块链服务（BCS）：提供一站式区块链解决方案，帮助企业快速搭建和管理区块链网络。产品介绍链接
- 腾讯云视频处理（VOD）：提供视频上传、转码、剪辑、播放等一系列视频处理服务。产品介绍链接
- 物联网套件（IoT Hub）：提供全面的物联网解决方案，帮助连接和管理物联网设备。产品介绍链接
- 云原生应用引擎（TKE）：提供高度可扩展的容器化应用管理平台，支持快速部署和运行应用。产品介绍链接
请注意，以上只是腾讯云的一些产品示例，其他云计算品牌商也提供类似的产品和服务。
相关·内容
2回答
C标准是否要求指针为(整数)数字？
有人可能会说，是的，因为指针运算.
但是另一方面，像--或++这样的操作可以理解为以前的内存位置，下一个内存位置，这取决于它们在标准中的描述方式，而实际的实现可以使用任何表示来保存指针数据(只要实现了上述操作).
想到了另一个问题-C是否要求数组/缓冲区等是连续的，即下一个元素存储在下一个内存位置(++p，其中p是一个指针)？我之所以这样问，是因为您经常可以在网上看到似乎认为是这样的实现。
浏览 1提问于2019-12-25得票数 1
回答已采纳
最后一行生成“对二进制表达式无效的操作数”。想弄明白为什么。这是否意味着"p2-p1“是位于p3右侧的二进制表达式"-”的无效操作数？有什么规定我能遵守吗？我很困惑，因为"3-2-1“整数是有效的。
int array[3] = {1,2,3};
int* p1 = &array[0];
int* p2 = &array[1];
int* p3 = &array[2];
p3-p2-p1;
浏览 1提问于2015-10-04得票数 0
回答已采纳
3回答
下列行为是否会引发第4行和/或第5行中未定义的行为：
#include <stdio.h>
int main(void)
{
char s[] = "foo";
char * p = s - 1; /* line 4 */
printf("%s\n", p + 1); /* line 5 */
return 0;
}
浏览 3提问于2013-08-12得票数 15
回答已采纳
如果我正确理解，这个程序在C++中有未定义的行为，因为中间值p + 1是指向未初始化内存的指针：
int main () {
int x = 0;
int *p = &x;
p = p + 1 - 1;
*p = 5;
}
如果void被放在main的参数列表中(按照C语法的要求)，它是否也是C中未定义的行为？
浏览 8提问于2022-02-14得票数 3
回答已采纳
1回答
我想知道以下代码是否被C++标准所接受。
int n{ 10 };
double* p = new double[0];
double* q = p + n;
std::cout << "n = " << static_cast<int>(q - p) << std::endl;
我要那个程序显示n的值。
由于这个问题可能看起来很奇怪，下面是对这个问题的起源的解释。我想在2D中设计一个动态数组类(想一想std::vector类型的容器，而不是2D而不是1D)。一个直截了当的办法是：
template <typename T&
浏览 4提问于2014-10-29得票数 2
回答已采纳
5回答
我一直在想:按照定义，ptrdiff_t不应该能够保存任何两个指针的差异吗？当两个指针太远时，它怎么会失败呢？(我不是指任何特定的语言.我指的是所有这种类型的语言。)
(例如，当您有32位指针时，从带有地址1的字节指针中减去带有地址0xFFFFFFFF的指针，它会溢出符号位.)
浏览 7提问于2011-02-01得票数 17
回答已采纳
下面的文本来自C++在线课程。它说vector类的构造函数
template <class InputIterator>
vector ( InputIterator first, InputIterator last, const Allocator& = Allocator() );
可以接收指针作为第一(InputIterator first)和第二参数(InputIterator last)。
下一个构造函数使用迭代器初始化自身。它将创建一个向量，其中包含从第一个(包括)到最后(排它)的值副本。在最典型的情况下，此构造函数使用已经存在的集合中
浏览 5提问于2015-07-17得票数 0
我想知道是什么定义了内存对象的起始地址比对象的结尾更低或更高。例如：
char buffer[10];
char* p = &buffer[0];
printf("%p\n",p); //0x7fff064a6276
p = &buffer[9];
printf("%p\n",p); //0x7fff064a627f
在本例中，对象的起始地址低于结束地址。即使堆栈朝着较低的地址增长。
为什么布局与堆栈增长的方向相反？
是什么定义了这个方向？语言？奥斯？编译器？CPU架构？
对象的结尾总是在一个比开头更高的地址上吗？
浏览 1提问于2016-10-08得票数 0
回答已采纳
在C语言中，为了进一步的算术，保持指针不受限制(不取消引用)安全吗？
void f(int *array)
{
int *i = array - 1; // OOB
while(...) {
++i;
...
}
}
void g(int *array, int *end /* past-the-end pointer: OOB */)
{
while(array != end) {
...
++array;
}
}
我想有些极端的情况，如果地址是记忆中的第一个或最后一个.
浏览 3提问于2021-01-10得票数 11
回答已采纳
1回答
最近我遇到一个C++类，它实现了一个基于非零索引的数组。也就是说，可以初始化这个类，使其具有一个有效的索引范围，比如15.19。这个类使用索引0计算元素的入口，尽管这可能是在分配的地址空间之外，并存储该地址。然后，使用这个元素0地址通过operator[]处理元素访问。一些示例代码(简化)：
template <typename T>
class NonZeroArray
{
public:
NonZeroArray(int min_index, int size, T default_element) :
m_min_index(min_index),
浏览 3提问于2014-01-03得票数 0
回答已采纳
根据此，允许将指针与进行比较，后者是数组对象的最后一个元素。
根据@jalf注释，禁止在数组对象的第一个元素之前将指针与指针进行比较。
example1
int array[10];
int *ptr;
for(ptr=&array[9]; ptr>(array-1); ptr--) {…}
example2
int array[10];
int *ptr;
for(ptr=&array[9]; ptr>=(array); ptr--) {…}
example1和example2都被禁止了吗？
C标准是否证明禁止在数组对象的第一个元素之前将指针与进行
浏览 2提问于2013-04-26得票数 10
回答已采纳
8回答
通过指针访问数组
、、
让int * ptr,array[10]; ptr= array;。现在，数组相邻位置中的每个存储单元都有一个固定的大小。如果第一个小区的地址是1234，那么下一个小区必须位于1238地址。但是我们使用指针作为*(ptr+1)来访问它。我对此感到困惑。有什么消息来源或答案吗？谢谢。
浏览 2提问于2013-08-02得票数 0
回答已采纳
在C18中我们有：
§6.5.9p10
两个指针比较相等的当且仅当两者都是空指针，都是指向同一个对象的指针(包括指向对象和其开头的子对象的指针)或函数，它们都是指向同一个数组对象的最后一个元素的指针，或一个指针指向一个数组对象结束后的一个指针，另一个指针指向一个不同数组对象的开始，该指针恰好紧跟在地址空间中的第一个数组对象后面。
所以对于int a[4][2] = {{1, 2}, {3, 4}, {5, 6}, {7, 8}}，我们可以拥有a[1] == a[0] + 2。
因此，这能保证*(a[1]) == *(a[0] + 2)
浏览 1提问于2020-08-01得票数 4
回答已采纳
2回答
在我检查一些现有代码的过程中，我遇到了这一行：
char *s = malloc(SIZE);
scanf("%s", s);
char *y = s + strlen(s);
假设scanf()函数成功，那么向字符数组添加一个整数有什么意义呢？
我的期望是获得一个包含s内容的新字符串和另一个包含整数的ASCII码(或至少是原始字符串)的字符。
通过调试这段代码，似乎在操作之后使用了y=""。
对此行为的解释是什么？
浏览 10提问于2018-08-28得票数 0
回答已采纳
2回答
这是一个测量C基础知识的作业和问题，它是Coursera.org课程的一部分。但是，这只是为了衡量你是否能够完成这门课程。这只是一个复制粘贴的实际问题。我在所有其他问题上都做得很好，只是我似乎没有理解以下的问题：
假设您正在编译一个32位平台和== 4 ( int )。如果c是int*类型，b是int类型，那么以下哪一项等同于cb？
可能的答案：
-1 * b[c]
*(c+b)
none of the above
*c+b
c[b][0]
我要问的是，从上述可能性中得到正确的答案是什么，为什么呢？我的意思是，用什么逻辑来得出结果呢？我应该读些什么才能理解到达那里的程序？
浏览 4提问于2015-10-07得票数 1
回答已采纳
1回答
我尝试使用二维字符数组来存储字符串，然后使用函数strcmp来比较两个相邻的字符串。
这是代码，这是成功的代码。
#include<stdio.h>
#include<string.h>
int main()
{
char a[20][20];
for(int i=0;i<20;i++)
scanf("%s",a[i]);//input
for(int i=1;i<20;i++)
{
if(strcmp(a[i],a[i-1])>0)//compare
{
浏览 3提问于2019-12-20得票数 2
回答已采纳
基于这个问题( )，有一个关于这一行的答案( )：
int *ptr = (int*)(&a+1);
他说：
the cast (int*) was hiding this bug。
因此，我带着以下几点：
#include <stdio.h>
int main( void ){
int a[5] = {1,2,3,4,5};
int *ptr = *( ( &a ) + 1 );
printf("%d", *(ptr-1) );
}
我想知道这是否：
int *ptr = *( ( &a ) + 1 );
标准
浏览 0提问于2018-06-26得票数 10
回答已采纳
虽然我不知道这个功能的名称：
a = []
a[57] = "test";
console.log(a.length)
console.log(a[57])
console.log(a)
我很敬畏这是可能的。来自C背景，这种行为与分配内存非常不同。所以有几个问题：
Javascript是否为数组中的前57个“空”条目分配内存？
如果不是，Javascript如何保存O(1)以使用分段内存地址进行查找？
Javascript是真正的Array还是一个以整数作为键的对象？
这种设计模式叫什么，这样我就可以进一步研究它了？
浏览 0提问于2018-09-05得票数 1
回答已采纳
我很难理解C中的一件事，我在"ANSI“中读过这样的语句，比如a[n]，其中a是数组，这实际上等同于*(a+n)。下面是我编写的一个小代码片段，用于检查：
#include <stdio.h>
int main(void)
{
int a[10] = {0,1,2,3,4,5,6,7,8,9};
int *p = a;
printf("sizeof a: %d\n", sizeof(a));
printf("sizeof p: %d\n", sizeof(p));
return 0;
}
执行代码后，程
浏览 7提问于2015-04-15得票数 4
回答已采纳
2回答
我在看 of 的源代码。
// regs16 and reg8 point to F000:0, the start of memory-mapped registers. CS is initialised to F000
regs16 = (unsigned short *)(regs8 = mem + REGS_BASE);
而REGS_BASE是
#define RAM_SIZE 0x10FFF0
#define REGS_BASE 0xF0000
将mem、regs8和regs16定义为
unsigned char mem[RAM_SIZE],*regs8;
unsigned sho
浏览 8提问于2021-04-28得票数 1
回答已采纳
为什么在C中只声明int a3就可以编译2a？
1 #include <stdio.h>
2
3 int main(int argc, char **argv)
4 {
5 int a[3] = {1, 2, 3};
6 printf("a[2] is: %d\n", a[2]);
7 printf("2[a] is: %d\n", 2[a]);
8
9 return 0;
10 }
和输出都是3，怎么解释呢？
浏览 1提问于2011-04-21得票数 2
回答已采纳
5回答
结构中相同类型的连续成员之间的指针算法过去是一种常见的做法，而指针算法仅在数组中有效。在C++中，它将被解释为未定义的行为，因为数组只能通过声明或新表达式创建。但是C语言将数组定义为具有特定成员对象类型(称为元素类型)的连续分配的非空对象集。(n1570 C11草案，6.2.5类型，第20节)。因此，只要我们能够确保成员是连续的(意味着它们之间没有填充)，那么将其视为数组是合法的。
下面是一个简化的示例，它在没有警告的情况下编译，并在运行时给出预期的结果：
#include <stdio.h>
#include <stddef.h>
#include <asser
浏览 13提问于2018-01-08得票数 5
回答已采纳
我正在调试我的代码，看起来内置函数contains在我的例子中不能正常工作。看：
List<Integer[]> allVariables = new ArrayList<Integer[]>();
Integer[] cols = {1};
该列表包含值：
[0] = Integer[1] => {1}
[1] = Integer[4] => {1,2,3,4}
因此，下面的IF表达式必须为TRUE，但它为false：
if (allVariables.contains(cols[0])) {
//...
}
有什么问题吗？
浏览 3提问于2012-01-03得票数 1
回答已采纳
1回答
考虑这一情况：
int *ptr;
int offset;
ptr = <some_address>;
offset = 10;
假设offset是32位变量.ptr有int*类型，目标体系结构是64位(所以ptr是8字节变量)，offset是int类型。在计算表达式*(ptr + offset)的值时将执行什么转换？在2003年的C++标准中，我可以在哪里读到它呢？
浏览 10提问于2015-05-07得票数 2
回答已采纳
4回答
假设我想为3个整数分配内存：
int *pn = malloc(3 * sizeof(*pn));
现在为它们赋值，我这样做：
pn[0] = 5550;
pn[1] = 11;
pn[2] = 70000;
要访问第二个值，请执行以下操作：
pn[1]
但n运算符只是*(a+n)的快捷方式。那么这意味着我将访问索引之后的第一个字节。但是int是4字节长，所以我不应该这样做吗？
*(a+sizeof(*a)*n)
而不是？它怎麽工作?
浏览 3提问于2013-11-26得票数 8
如果你有以下代码，其中p是一个指针：
p = p + strlen(p) + size_t(1);
既然strlen()和size_t都是size_t，我应该将代码转换为ptrdiff_t吗？
p = p + (ptrdiff_t)(strlen(p) + size_t(1));
如果是这样，为什么？
谢谢，格雷格
浏览 0提问于2010-12-07得票数 17
回答已采纳
这里有一个简单的程序来解释我的意思。给定长度n，它初始化由标准输入读取的n个整数序列。
int n, *seq, *current;
scanf("%d", &n);
seq = malloc(n*sizeof(int));
for (current = seq; current - seq < n; current++)
scanf("%d", current);
我对current的最后一次增量表示怀疑，这使得它指向了分配内存之外的某些内容。显然，从那个位置读取是错误的。但如果我不看那个位置呢？
该程序运行正常，但我的问题是:这是一个标准和
浏览 6提问于2013-11-01得票数 1
回答已采纳
1回答
C99嵌套数组未定义行为
、、、
在我们的讲座中，我们最近研究了指针相等的c99标准(6.5.9.6)，并将其应用于嵌套数组。在这里，它指出，只有当“一个指针指向一个数组对象结束后的一个指针，另一个指针指向另一个数组对象的开始，而这个指针恰好紧跟地址空间中的第一个数组对象”时，指针才能保证是相等的。
然后教授解释说，这就是为什么数组访问a在技术上没有定义为维度为4*5的嵌套数组。这是真的吗？如果是这样的话，为什么要定义负指数，例如a1
浏览 1提问于2020-10-21得票数 1
回答已采纳
2回答
#include <stdio.h>
int sum2d(int row, int col, int p[row][col]);
int main(void)
{
int a[2][3] = {{1, 2, 3}, {4, 5, 6}};
printf("%d\n", sum2d(2, 3, a));
return 0;
}
int sum2d(int row, int col, int p[row][col])
{
int total = 0;
for (int i = 0; i < row; i++)
浏览 1提问于2018-10-17得票数 1
回答已采纳
4回答
int a[10];
printf("%p ", &a);
将显示数组a的地址。
所以，如果我执行一个重定向，*(&a)，为什么我没有得到存储在a[0]中的值。在C语言中，我应该获取a的地址的规则是什么？是的，这是有意义的，我得到了a的地址，因为*和&会相互抵消，导致简单的a，这是a的地址。
浏览 1提问于2012-08-17得票数 1
回答已采纳
2回答
我最初认为它对指针和数组有不同的用途。在前一种情况下，它将括号中的任何内容添加到指针中，然后取消和；在后一种情况下，它只会产生数组的ith元素。
然后，我意识到数组变量返回指向第一个元素的指针，因此操作符在每种情况下都执行相同的操作:偏移和取消引用。
括号[]操作符在C中确实只有一个用途吗？
浏览 5提问于2013-11-05得票数 5
回答已采纳
5回答
这个代码的行为定义得很好吗？
#include <stdio.h>
#include <stdint.h>
int main(void)
{
void *ptr = (char *)0x01;
size_t val;
ptr = (char *)ptr + 1;
val = (size_t)(uintptr_t)ptr;
printf("%zu\n", val);
return 0;
}
我的意思是，即使指针指向某个随机地址，我们能给指针赋值并增加它吗？(我知道你不能取消它)
浏览 1提问于2018-06-28得票数 54
回答已采纳
1回答
让我们有一个char数组：
char arr[(size_t)PTRDIFF_MAX + (size_t)2];
让我们承认，我们有一个内存充足的系统。
以数组表示法或指针表示法访问数组是定义、未定义还是实现定义行为？
char c = arr[(size_t)PTRDIFF_MAX + (size_t)1];
char d = *(&arr[0] + ((size_t)PTRDIFF_MAX + (size_t)1));
我担心，在访问之前，索引可能被转换为ptrdiff_t，从而导致索引无效。
编辑：
在这种情况下，不可能有这么多元素的数组，让我们将类似的情况放在下面：
我们有一
浏览 5提问于2020-07-24得票数 0
回答已采纳
3回答
我有一个malloc‘’ed的指针数组，它形成了一个哈希表。要遍历哈希表，我需要使用指针算法，例如：
node_t ** tc = table;
size_t tcs = sizeof(node_t *);
for(long i = 0; i < tableSize; tc+=tcs, ++i) {
// Do some stuff with *tcs location in the table.
}
问题是，我是否应该将sizeof()返回的sizeof()转换为ptrdiff_t，以便在for条件的增量部分中正确添加？或者说这对加法有影响吗？
浏览 9提问于2015-05-17得票数 1
回答已采纳
6回答
在我正在编写的算法中，我可以使用以下方法(当然可以简化)
int a[3] = {1,2,3};
int b = a[3];
当用于填充b溢出的索引时，我从不使用b的值。代码是否仍然不正确？我要做一个明确的边界检查吗？
浏览 8提问于2011-07-04得票数 6
回答已采纳
5回答
如果在Java中数组被视为对象，如果我们有一个类似整数数组的多维数组，那么这个多维数组也是一个对象数组是正确的吗？我有点困惑，因为我读到数组只能包含两种类型，即基元或引用，那么如果一个数组包含一个数组，那么将其视为对象的数组是否正确？
浏览 0提问于2014-01-10得票数 0
我目前正在使用PHP简单的HTML DOM解析器来获取数据。有关解析器的更多信息，您可以在这里查看：
我正在处理一个解析Javascript变量的脚本，我希望它们是一个简单的文本。
下面是我解析的页面：
下面是我用于解析的代码：
<?PHP
include_once('simple_html_dom.php');
$url = "http://www.sportsdirect.com/adidas-adi5-x-ite-mens-astro-turf-trainers-263185?colcode=26318536";
$curl = curl_init
浏览 1提问于2014-08-06得票数 0
2回答
考虑以下代码：
#include <iostream>
int main()
{
int index;
std::cin >> index;
int* dynArray = new int[5];
dynArray[index] = 1;
int stackArray[5];
stackArray[index] = 1;
}
我确信，dynArray是一个简单的int*指针，它在堆栈上需要额外的sizeof(int*)字节。
问题1：是否在堆栈上为stackArray创建了额外的指针变量？如果是的话，这种情况总是发生
浏览 7提问于2014-05-24得票数 0
回答已采纳
3回答
C将数组视为指针
、、、、
在C中，我了解到数组的名称是指向第一个索引的指针，但为什么我不能写下面的内容：
int mat[5][4];
*mat=1;
浏览 1提问于2020-07-15得票数 0
7回答
我对C/C++盲目递增指针的行为有一个疑问。
因此，我有一个指向int的指针作为函数的参数
func(int* thePointer) {...
我在这个函数中有一个循环
while(*thePointer) {
++thePointer;
}
我知道只要内存中的int超出了这个指针，循环就会继续，但是如果内存属于另一种内存类型呢?假设你增加到double的前4个字节，int还会有值吗/循环会在这种情况下继续吗？
免责声明:我知道这很可能是一种糟糕的做法。这是一个纯粹的学术问题。
浏览 0提问于2011-02-18得票数 2
回答已采纳
5回答
可能重复：
我可以在数组中使用负索引吗？
#include <stdio.h>
int main(void)
{
char a[] = "pascual";
char *p = a;
p += 3;
printf("%c\n", p[-1]); /* -1 is valid here? */
return 0;
}
浏览 82提问于2012-10-06得票数 5
回答已采纳
我偶尔会使用多维数组，并好奇标准(C11和/或C++11)对使用比数组所声明的“维度”更少的索引行为说了些什么。
给予：
int a[2][2][2] = {{{1, 2}, {3, 4}}, {{5, 6}, {7, 8}}};
标准是否规定了什么类型的a[1]或a[0][1]，这是合法的，以及它是否应该像预期的那样正确地索引子数组？
auto& b = a[1];
std::cout << b[1][1];
浏览 3提问于2013-08-01得票数 5
回答已采纳
4回答
在c++中，const数组arr包含介于0到80之间的100个数字。
如果我选择arr中的数字为chars，那么每次将它们作为双指针(即doublepointer[arr[i]] )上的索引时，都会隐式转换为int吗？
浏览 4提问于2014-08-10得票数 4
回答已采纳
我有一个关于JavaScript数组的一般性问题。JavaScript中的数组索引是否作为字符串在内部处理？
我在某个地方读到，因为数组是JavaScript中的对象，所以索引实际上是一个字符串。我对此感到有点困惑，很高兴得到任何解释。
浏览 7提问于2014-12-18得票数 18
回答已采纳
我在RSpec中得到了这个错误。是否有任何have_selector文档可以解释选项哈希中的每个键以及它到底做了什么？
invalid keys :content, should be one of :text, :visible, :between, :count, :maximum, :minimum, :exact, :match, :wait
浏览 0提问于2014-05-30得票数 12
1回答
我遇到了一种观点，如果我们有指向指针的指针，我们可以通过[][]取消引用，以防分配的内存相邻。如果没有，则只能使用指针算法来取消引用。但我不能完全重现这种情况，下面是一个示例代码：
#include <stdio.h>
#include <stdlib.h>
#define ITEMS_NO 3
#define LETTERS_NO 4
int main(void)
{
char* theArray[ITEMS_NO];
char* dummyArr[ITEMS_NO];
for (int i = 0; i < ITEMS_N
浏览 3提问于2019-12-11得票数 0
回答已采纳
1回答
我有结构：
typedef struct
{
int a;
int b;
int c;
}Z;
代码：
int main()
{
Z *a = (Z*)malloc(sizeof(Z)*8);
Z *b = (Z*)malloc(sizeof(Z)*8);
printf("%lu\n", sizeof(Z));
printf("%p %p\n", b, a);
printf("%lu\n", b - a);
}
产出：
12
0x89a080 0x89a010
12297829382
浏览 1提问于2015-02-21得票数 2
回答已采纳
3回答
在以下情况下，我有一个包含指向整数变量的指针的结构，如下所示：
struct Structure[] = {
{ &Var[0], &Var[1] },
{ &Var[2], &Var[3] }
};
问题是:第一次填充此结构时，Var未初始化。(如：NULL)在(第一次传递)之后不久，变量Var将被初始化，并相应地更新引用。
我看不出有什么理由出故障，但我希望你对此有专门的意见。将对无效内存的引用(带有数组下标)放入这样的数组中是否合法？还是我需要一种不同的方法来应对这种情况？
在第一次初始化之前，我不会访问这些变量的内容。
非常感谢。
编辑
浏览 1提问于2013-08-05得票数 7
回答已采纳
2回答
如果我把这个写在C里，
int a[50];
我使用a，它实际上指向数组的第一个元素的地址。
但是，如果我有int b[10][10]，并且使用b或b[0]，那么它将指向什么呢？
第二，如果我知道，
`&a[0]`
这基本上给出了第一个元素的地址，但是如果我这样做了，&a，这实际上意味着什么？还有像&a + 1这样的操作。基本上，我们是在计算数组的第一个元素的地址吗？
或者说，如果我有一个3d数组，int c[10][10][10]，那么c意味着什么？它将指向哪个元素？或者，如果我这样做了，c[0]+1，这将指向数组的哪个部分？
谢谢!
浏览 1提问于2014-07-20得票数 1
回答已采纳
2回答
我有一个类，它只是一个原始指针包装器。我想知道我是否可以申报：
operator++()
operator--()
operator++(int)
operator--(int)
作为noexcept。这些操作符可能抛出的唯一原因是原始指针会抛出。所以问题是:在已经是--的指针上调用++时会发生什么，而在指针上调用++时会发生什么呢？
浏览 4提问于2015-10-18得票数 3
回答已采纳
扫码
添加站长 进交流群
领取专属 10元无门槛券
手把手带您无忧上云
相关资讯
热门标签
云服务器
ICP备案
对象存储
即时通信 IM
实时音视频活动推荐
腾讯云开发者
