小编ggr*_*grr的帖子

我知道未初始化的局部变量是未定义的行为(UB),并且该值可能具有可能影响进一步操作的陷阱表示,但有时我想仅使用随机数进行可视化表示,并且不会在其他部分使用它们.例如,程序在视觉效果中设置具有随机颜色的东西,例如:

void updateEffect(){
    for(int i=0;i<1000;i++){
        int r;
        int g;
        int b;
        star[i].setColor(r%255,g%255,b%255);
        bool isVisible;
        star[i].setVisible(isVisible);
    }
}

是不是比它快

void updateEffect(){
    for(int i=0;i<1000;i++){
        star[i].setColor(rand()%255,rand()%255,rand()%255);
        star[i].setVisible(rand()%2==0?true:false);
    }
}

并且还比其他随机数发生器更快？

我找到了两个long int long并且int long long可以编译变量类型.是否有任何区别long int long,int long long,long long和long long int？

一般来说,如果它的数量相同,那么它的类型是否相同long？

1长:

long l;
int long il;
long int li;

2长:

long long ll;
int long long ill;
long int long lil;
long long int lli;

如果以上是正确的,以下声明是否也相同？

long long* llp;
int long long* illp;
long int long* lilp;
long long int* llip;

今天我发现了奇怪的语法

 int _$[:>=<%-!.0,};

在一些旧代码中,但实际上代码没有被注释.似乎没有关于此行的编译错误的报告.我单独测试它也可以编译:

int main(){
    int _$[:>=<%-!.0,};
    return 0;
}

为什么要编译？

注意:我认为,所谓的重复问题主要与"<"和">"比较有关,但与"=="比较无关,因此不回答我关于"=="运算符性能的问题.

很长一段时间,我相信"处理"排序数组应该比未排序数组更快.起初,我认为在排序数组中使用"=="应该比未排序数组更快,因为 - 我猜 - 分支预测如何工作:

UNSORTEDARRAY:

5 == 100 F
43 == 100 F
100 == 100 T
250 == 100 F
6 == 100 F
(other elements to check)

SORTEDARRAY:

5 == 100 F
6 == 100 F
43 == 100 F
100 == 100 T
(no need to check other elements, so all are F)

所以我猜SORTEDARRAY应该比UNSORTEDARRAY更快,但今天我用代码在标题中生成2个数组进行测试,并且分支预测似乎不像我想的那样工作.

我生成了一个未排序的数组和一个排序的数组来测试:

srand(time(NULL));
int UNSORTEDARRAY[524288];
int SORTEDARRAY[sizeof(UNSORTEDARRAY)/sizeof(int)];
for(int i=0;i<sizeof(SORTEDARRAY)/sizeof(int);i++){
    SORTEDARRAY[i]=UNSORTEDARRAY[i]=rand();
}
sort(SORTEDARRAY,SORTEDARRAY+sizeof(SORTEDARRAY)/sizeof(int));
string u="const int UNSORTEDARRAY[]={";
string s="const int SORTEDARRAY[]={";
for(int i=0;i<sizeof(UNSORTEDARRAY)/sizeof(int);i++){ …

例如,它有一个透明背景的图像:

我想在其上添加一个灰色叠加层(例如,div或画布......):

但我希望叠加层自动忽略图像上的透明区域:

纯HTML和CSS(例如div,canvas ......)可以这样做吗？

本来我喜欢用这样的东西:

(true?a:b).test()

代替

(true?a.test():b.test())

如果函数具有相同的名称,为了节省打字时间,最初我认为它应该是有效的,但我发现:

#include <stdio.h>
class A{
public:
    char test(){
        return 'A';
    }
};

class B{
public:
    char test(){
        return 'B';
    }
};

int main(){
    printf("%c\n",(false?A():B()).test());
    return 0;
}

无法编译,但如果B是子类A:

#include <stdio.h>
class A{
public:
    char test(){
        return 'A';
    }
};

class B : public A{
public:
    char test(){
        return 'B';
    }
};

int main(){
    printf("%c\n",(false?A():B()).test());
    return 0;
}

它可以编译,为什么？

例如,如果我有这么多类在同一平台上具有相同的前缀:

在android中:

Printer *p=new AndroidPrinter();
Writer *w=new AndroidWriter();
Connector *c=new AndroidConnector();

在iOS中:

Printer *p=new IOSPrinter();
Writer *w=new IOSWriter();
Connector *c=new IOSConnector();

可以像这样定义类名的一部分:

#define PREFIX Android

int main(){
    Printer *p=new PREFIXPrinter();
    Writer *w=new PREFIXWriter();
    Connector *c=new PREFIXConnector();
    return 0;
}

代替:

#define PLATFORM 0

#if PLATFORM==0
#define PRINTER AndroidPrinter
#else
#define PRINTER IOSPrinter
#endif

#if PLATFORM==0
#define WRITER AndroidWriter
#else
#define WRITER IOSWriter
#endif

#if PLATFORM==0
#define CONNECTOR AndroidConnector
#else
#define CONNECTOR IOSConnector
#endif

int main(){
    Printer *p=new PRINTER();
    Writer *w=new …

我想创建一个可以在psudocode中处理任意维向量,函数的函数:

template<class T>
void printVector(vector<T> t){
    if(T==vector){
        printf("[");
        for(auto it=t.begin(),it!=t.end();++it){
            printVector(*it);
        }
        printf("]");
    }else{
        printf("%d ",t);
    }
}

例如:

vector<int> a;
a.push_back(12);
a.push_back(34);

printVector(a);

输出应该是[12 34],

vector<vector<int> > b;
vector<int> b1;
b1.push_back(1);
b1.push_back(2);
b.push_back(b1);

vector<int> b2;
b2.push_back(3);
b2.push_back(4);
b.push_back(b2);

printVector(b);

输出应为[[1 2] [3 4]]

例如,0,0.5,0.15625,1,2,3 ......是从IEEE 754转换而来的值.它们的硬编码版本是否精确？

例如:

是

float a=0;
if(a==0){
    return true;
}

总是回归真实？其他例子:

float a=0.5;
float b=0.25;
float c=0.125;

a*b总是等于0.125而a*b == c总是如此？还有一个例子:

int a=123;
float b=0.5;

a*b总是61.5？或者一般来说,整数乘以IEEE 754二进制浮点精确？

或者更一般的问题:如果值是硬编码并且值和结果都可以用IEEE 754中的二进制格式表示(例如:0.5 - 0.125),那么值是否精确？

我发现离子项目中我的.ts文件的一些import语句写成:

import { Component } from '@angular/core'

代替

import { Component } from '@angular/core';

,错过了分号,项目似乎正常运行,导入语句实际上最后需要分号吗？