小编Che*_*Alf的帖子

_{注意：这是一个有问必答的问题，目的是记录其他人可能会发现有用的技术，并可能了解其他人的更好解决方案。请随意添加批评或问题作为评论。也可以随意添加其他答案。:)}

Visual C++ 一直有一个语言扩展__uuidof(类名)，可以检索UUID，一个 128 位通用唯一标识符，前提是 UUID 通过 与类关联__declspec，这也是一个 Visual C++ 语言扩展：

#include <guiddef.h>        // GUID, another name for UUID

class
    __declspec( uuid( "290ff5cb-3a21-4740-bfda-2697ca13deae" ) )
    Foo
{};

#include <iostream>
using namespace std;

auto main()
    -> int
{
    cout << hex << __uuidof( Foo ).Data1 << endl;   // 290ff5cb
}

MinGW g++ 4.8.2（可能还有一些早期版本）支持__uuidof，但不支持 MSVC 的__declspec. 因此，使用 g++ 4.8.2 编译上述内容会失败，至少在我使用的 Nuwen 发行版中是这样。首先 g++ 发出警告“'uuid'属性指令被忽略”，然后一个链接器错误“未定义引用到_GUID …

我正在为一个对象数组编写一个模板类,称之为arrayobjclass,它包含指向其他对象的指针,特别是我实现中的其他数组.数组也作为对象实现,称之为arrayclass.寻找准备好的最小变化.

当我尝试使用以下行测试我的类时,

g++ main.cpp arrayclass.cpp arrayobjclass.cpp -o arrayobj

我收到以下错误:

/tmp/ccEpROXj.o(.text+0x17c): In function `main':
: undefined reference to `arrayobjclass<arrayclass, int>::arrayobjclass(int)'
/tmp/ccEpROXj.o(.text+0x1dc): In function `main':
: undefined reference to `arrayobjclass<arrayclass, int>::addelem(arrayclass*)'
collect2: ld returned 1 exit status

我真的无法理解有什么不对.任何帮助,将不胜感激.如果有帮助,代码的简短相关部分如下.提前致谢!

这就是我的主要内容:

#include "arrayclass.h"
#include "arrayobjclass.h"
#include <iostream>

// 5 arrays of 10 maxsize each
#define MAXSIZE_array 10
#define NUMB_objs 5

using namespace std;

int main () {

    //create a simple array as an arrayclass object
    arrayclass * numbers1 = new arrayclass (MAXSIZE_array);

    //array of …

我正在研究一些执行图像处理的代码,它从原始图像文件中读取每16位并将每个块存储到一个数组中.该阵列需要1392列和1024行.我正在使用fread从原始文件中读取数据块:

    fread(&q1[0][0], sizeof(uint16_t), NUM_COLS*NUM_ROWS*sizeof(uint16_t), fp);

这似乎一直工作到q1 [0] [280],它突然停止(280以上的值为0).

我以前直接声明了数组:

uint16_t q1[NUM_COLS][NUM_ROWS];

但我认为它需要动态分配才能存储超过280个值,所以我重新写了它

    uint16_t** arr;
    arr= (uint16_t**) malloc(NUM_ROWS * sizeof(uint16_t *));
if (arr == NULL) {
    fprintf(stderr, "out of memory\n");

}
for(int i=0; i<NUM_ROWS; i++) {
    arr[i]= (uint16_t*) malloc(NUM_COLS * sizeof(uint16_t));
    if(arr[i] == NULL) {
        fprintf(stderr, "out of memory\n");

    }
}

不幸的是,这仍然停留在索引280处.任何关于它为何停止的想法(或者是否有更好的方法)？

我正在寻求实施冒泡排序.我有以下代码,它使用for循环内部的do循环.如何将其转换为使用两个for循环的冒泡排序？

这是我的代码:

do {
    switched = false;
    for (int i = 1; i < size; i++) {
        if (a[i] < a[i-1]) {
            int temp = a[i];
            a[i] = a[i-1];
            a[i-1] = temp;
            switched = true;
        }
    }
} while (switched);

(这是标记的作业,但这是为期末考试而不是实际的家庭作业.)

当我试图阐明我的问题时,请耐心等待.我想我想要了解的是这样的东西:

class Base1 { public: int value { 5 }; };
class Base2 { /* fields */ };

class Derived1 : public Base1 { ... };
class Derived2 : public Base2, public Derived1 { ... };

编译器如何解决这样的代码的内存偏移？

void base1_action(Base1 *instance) { 
    cout << instance->value << endl;
}

void change_base(Base2* instance) {
    base1_action(reinterpret_cast<Base1*>(instance));
}

int main() {
    Base2* instance = new Derived2;
    change_base(instance);
}

也就是说,如果在main实际的对象实例的类型的Derived2,当碱基变化在发生change_base,从Base2到Base1,怎么是编译器能够知道如何重新计算补偿的对象,这样,当base1_action被调用时,它得到一个指针正确的偏移量Base1？

换句话说,当存在多个继承时,编译器如何能够计算从一个基类到另一个基类的偏移量(而不是从已知派生类计算基类偏移量的更简单问题)？

希望我的问题有点清楚 …

从我所知,范围为基础的循环可以仅采取一个C语言风格的阵列,具有部件的功能的类型的对象begin()和end()定义,或一个类型的对象Type的量,游离的功能begin(Type)和end(Type)可以与ADL找到.

有没有办法让循环采用类型参数,所以像这样的代码编译？

class StaticVec{
//shortened implementation
    static myIterator begin();
    static myIterator end();
};

void foo() {
    for(auto elem : StaticVec){
       dosomething(elem);
    }
}

我想省略StaticVec::values()在循环中写入的必要性.

我有这段小代码:

#ifndef MODA
#define MODA

class CAdd {
public:
    CAdd(int a, int b) : result_(a + b) { }

    int getResult() const { return result_; }

private:
    int result_;
};

/*
int add(int a, int b) {
    return a + b;
}
*/
#end

#include "modA.h"

void doSomeCalc() {
    //int r = add(1, 2);
    int r = CAdd(1, 2).getResult();
}

#include "modA.h"

int main() {
    //int r = add(1, 2);
    int r = CAdd(1, 2).getResult();
    return 0; …

考虑到T来自类的构造函数的(直接或间接)成员函数的虚拟调用,T最多可以归结为T实现,下面的代码,具有不合格的调用,是否具有未定义的行为？

注意,为了避免噪音:如果您认为在从构造函数调用时不会虚拟调用成员函数,那么请不要在此处回答或评论,而是在单独的SO问题中提出该问题.谢谢.

struct Baze
{
    virtual void foo();
    virtual void bar() = 0;
    Baze(){ foo(); bar(); }
};

void Baze::foo() {}
void Baze::bar() {}

struct Derived: Baze
{
    void bar() override {}
};

int main()
{
    Derived{};
}

我最近编写了一个非常简单的代码class,它负责查找a中的min和max值std::vector,即使我将集合作为a const reference传递给class'构造函数然后更改向量(即将元素推入其中)或者从外面移除一个),内部的向量class保持不变.

#include <vector>
#include <algorithm>

class MinMaxFinder
{
public:
    MinMaxFinder(const std::vector<int>& numbers) : numbers(numbers)
    {
    }
    const int Min() const
    {
        this->findMinAndMax();
        return this->min;
    }
    const int Max() const
    {
        this->findMinAndMax();
        return this->max;
    }

protected:
    std::vector<int> numbers;
    int min;
    int max;

    void findMinAndMax()
    {
        // std::minmax_element call to find min and max values
    }
};

我认为传递引用的点是为了不复制大对象,但是我的代码现在的工作方式似乎是复制集合.

#include <vector>
#include <iostream>
#include "MinMaxFinder.h"

int main(int argc, char* argv[])
{
    std::vector<int> …

为什么以下c代码产生的实数仅在0到1之间(例如:0.840188,0.394383 ...等),double a,b当RAND_MAX的值出现时0.000000.不应该RAND_MAX设置rand()函数生成的数字的最大值？

    #include <stdio.h>
    #include <stdlib.h>
    int main()
    {

    double a,b,c;
    for (int i=0;i<100;i++){
    a=(double)rand()/(double)RAND_MAX;
    b=(double)rand()/(double)RAND_MAX;
    c=a-b;
    printf("itteration : %d values a=%f,b=%f,c=%f, RAND_MAX=%f \n",i,a,b,c,RAND_MAX);
    }  
    return 0;
    }