我一直在收到这个警告:
note: expected ‘const char **’ but argument is of type ‘char **’
现在,我通过将它们转换为传递参数const char **.还有其他方法我可以摆脱它吗？
在C++ 11中,a的字符std::string必须连续存储,如第21.4.1/5节所述:
basic_string对象中的char类对象应连续存储.也就是说,对于任何basic_string对象,标识&*(s.begin()+ n)==&*s.begin()+ n应该适用于n的所有值,使得0 <= n <s.size ().
但是,这里是§21.4.7.1如何列出两个函数来检索指向底层存储的指针(强调我的):
const charT*c_str()const noexcept;
const charT*data()const noexcept;
1返回:指针p,使得p + i ==&operator [](i)为[0,size()]中的每个i.
2复杂性:恒定时间.
3要求:程序不得更改存储在字符数组中的任何值.
我可以想到的第3点的一种可能性是指针可以通过对象的以下用途而变得无效(第21.4.1/6节):
即便如此,迭代器也会失效,但我们仍然可以修改它们,无论它们是什么.我们仍然可以使用指针,直到它变为无效以便从缓冲区读取.
为什么我们不能直接写入这个缓冲区？是因为它会使类处于不一致状态,例如,end()不会使用新结束更新？如果是这样,为什么允许直接写入类似的缓冲区std::vector？
用例包括能够将a的缓冲区传递std::string给C接口以检索字符串而不是传入一个字符串,vector<char>并使用迭代器初始化字符串:
std::string text;
text.resize(GetTextLength());
GetText(text.data());
有人可以澄清是否(和为什么)函数可以归因pure或const是否有一个指针参数.
根据GCC文件:
纯函数的一些常见示例是strlen或memcmp.
纯函数的要点是只需要为相同的参数调用一次,即如果编译器认为适合这样做,结果可以缓存,但是这对memcmp有什么作用？
例如:
char *x = calloc(1, 8);
char *y = calloc(1, 8);
if (memcmp(x, y, 8) > 0)
printf("x > y\n");
x[1] = 'a';
if (memcmp(x, y, 8) > 0)
printf("x > y\n");
第二次调用memcmp的参数与第一次调用相同(指针指向同一地址),编译器如何知道不使用第一次调用的结果,如果memcmp是纯粹的？
在我的情况下,我想将数组传递给纯函数,并仅根据数组计算结果.有人向我保证这没关系,并且当数组中的值发生变化但地址没有变化时,我的函数将被正确调用.
因为我是按照下观察出现了这个问题,约char[]和char*分歧.
#include <iostream>
typedef char ar[];
typedef char* pr;
void f2(ar x, pr y)
{
std::cout << std::is_same<decltype(x), decltype(y)>::value << '\n';
std::cout << std::is_same<ar, pr>::value << '\n';
}
int main()
{
char data[] = "data";
char *ptr = data;
f2(data,ptr);
return 0;
}
输出(在Apple LLVM版本4.2(clang-425.0.28)上)
1
0
为什么这些报告为不同的类型,但没有不同decltype()的？我怀疑它们实际上是由于它们的声明而不同类型typedef,但那么为什么变量报告为相同类型？
我一直在使用并行线程的矩阵乘法,这个代码,但我得到"由大小不同的整数转换为指针"错误
我不知道出了什么问题.我是pthread的新手,这是我到目前为止所做的:
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <sys/time.h>
#include <pthread.h>
#define NTHREADS 4
int dim ;
pthread_mutex_t m; /* Mutex protecting the sum value */
pthread_t thread_id[NTHREADS]; /* Thread ids */
float **A, **B, **C;
void *prod (void *s){
int *id=(int *)s;
int idd=*id;
/* Define local variables */
int i,j,k, start, end, len ;
float **Aa, **Bb, **Cc;
start = dim*idd; /* Start of this threads slice of the vectors */
end = start + dim; /* …这是关于UVa在线评判问题的链接.
https://uva.onlinejudge.org/index.php?option=com_onlinejudge&Itemid=8&category=29&page=show_problem&problem=1078
我的C代码是
#include <stdio.h>
double avg(double * arr,int students)
{
int i;
double average=0;
for(i=0;i<students;i++){
average=average+(*(arr+i));
}
average=average/students;
int temp=average*100;
average=temp/100.0;
return average;
}
double mon(double * arr,int students,double average)
{
int i;
double count=0;
for(i=0;i<students;i++){
if(*(arr+i)<average){
double temp=average-*(arr+i);
int a=temp*100;
temp=a/100.0;
count=count+temp;
}
}
return count;
}
int main(void)
{
// your code goes here
int students;
scanf("%d",&students);
while(students!=0){
double arr[students];
int i;
for(i=0;i<students;i++){
scanf("%lf",&arr[i]);
}
double average=avg(arr,students);
//printf("%lf\n",average);
double money=mon(arr,students,average);
printf("$%.2lf\n",money);
scanf("%d",&students);
}
return 0;
}
其中一个输入和输出是 …
我有一个带有多维数组的类:
可以使用此类创建一个,两个,......,n维数组
如果数组有n个维度,我想用n operator[]来获取一个对象:
例:
A a({2,2,2,2}];
a[0][1][1][0] = 5;
但数组不是指针的向量,导致其他向量等...
所以我希望operator []返回一个类对象,直到最后一个维度,然后返回一个整数
这是一个强烈简化的代码,但它显示了我的问题:
我收到的错误: "[Error] cannot convert 'A::B' to 'int' in initialization"
#include <cstddef> // nullptr_t, ptrdiff_t, size_t
#include <iostream> // cin, cout...
class A {
private:
static int* a;
public:
static int dimensions;
A(int i=0) {
dimensions = i;
a = new int[5];
for(int j=0; j<5; j++) a[j]=j;
};
class B{
public:
B operator[](std::ptrdiff_t);
};
class C: public B{
public:
int& operator[](std::ptrdiff_t);
};
B operator[](std::ptrdiff_t);
};
//int …我有定义项目顺序的向量(0..N-1),例如
{5, 0, 4, 3, 2, 1, 7, 6}.
我必须对该向量的子集进行排序.所以,因为{0, 1, 2, 5}我应该得到{5, 0, 2, 1}.
我测试了以下解决方案:
std::lower_bound.第二种解决方案似乎要快得多,尽管需要对子集进行排序.还有更好的解决方案吗？我使用的是C++/STL/Qt,但问题可能不依赖于语言.
在寻找关于以下内容的相关或重复问题后无济于事(我只能用边际正义来描述用C标记的指针算术和后减法问题的绝对数量,但足以说"船载"做了一个坟墓对结果集的不公平)我把它扔在戒指中,希望澄清或转介给我的副本.
如果将后递减运算符应用于如下所示的指针(数组序列的简单反向迭代),以下代码是否会调用未定义的行为？
#include <stdio.h>
#include <string.h>
int main()
{
char s[] = "some string";
const char *t = s + strlen(s);
while(t-->s)
fputc(*t, stdout);
fputc('\n', stdout);
return 0;
}
最近向我提出6.5.6.p8 Additive运算符,结合6.5.2.p4,Postfix递增和递减运算符,指定甚至在它已经包含调用未定义行为的基地址时执行后递减,无论是否评估(不是表达式结果)的结果值.我只是想知道是否确实如此.tstt--
标准的引用部分是:
6.5.6加法运算符
- 如果指针操作数和结果都指向同一个数组对象的元素,或者指向数组对象的最后一个元素,则评估不应产生溢出; 否则,行为未定义.
和...几乎紧密耦合的关系......
6.5.2.4后缀增量和减量运算符约束
- 后缀增量或减量运算符的操作数应具有原子,限定或非限定的实数或指针类型,并且应为可修改的左值.
语义
postfix ++运算符的结果是操作数的值.作为副作用,操作数对象的值递增(即,将相应类型的值1添加到其中).有关约束,类型和转换以及操作对指针的影响的信息,请参阅加法运算符和复合赋值的讨论.在更新操作数的存储值的副作用之前,对结果的值计算进行排序.对于不确定顺序的函数调用,后缀++的操作是单个评估.具有原子类型的对象上的Postfix ++是具有memory_order_seq_cst内存顺序语义的读 - 修改 - 写操作.98)
所述后缀-操作者是类似于后缀++操作,不同的是操作数的值被递减(即,相应的类型的值1被从中减去).
前向参考:加法运算符(6.5.6),复合赋值(6.5.16.2).
在发布的示例中使用post-decrement运算符的原因是为了避免针对数组的基址评估最终无效的地址值.例如,上面的代码是以下的重构:
#include <stdio.h>
#include <string.h>
int main()
{
char s[] = "some string";
size_t len = strlen(s);
char *t = …我有一个棘手的情况.它的简化形式是这样的
class Instruction
{
public:
virtual void execute() { }
};
class Add: public Instruction
{
private:
int a;
int b;
int c;
public:
Add(int x, int y, int z) {a=x;b=y;c=z;}
void execute() { a = b + c; }
};
然后在一个班级我做一些像......
void some_method()
{
vector<Instruction> v;
Instruction* i = new Add(1,2,3)
v.push_back(*i);
}
而在另一堂课......
void some_other_method()
{
Instruction ins = v.back();
ins.execute();
}
他们以某种方式分享这个教学载体.我担心的是我执行"执行"功能的部分.它会起作用吗？它会保留其添加类型吗？