标签: c++

我想以一种格式初始化一个数组,该格式使用逗号分隔花括号中包围的元素,例如:

int array[10]={1,2,3,4,5,6,7,8,9,10};

但是,我需要使用new运算符来分配内存,例如:

int *array = new int[10];

有没有办法结合这些方法,以便我可以使用new运算符分配内存并使用花括号初始化数组？

我自己和一些队友一直无法理解为什么下面的代码片段在使用JVM版本1.6u23到1.6u31(本帖子的最新版本)时不能提供正确的输出.此代码段代表了一个更大问题的简化:

更新:稍微修改了示例,重点关注"virtual_function()"似乎没有被调用的问题.

更新:根据迄今为止的评论更简化示例.

NodeTester.cpp:

#include <iostream>
#include <jni.h>

class Node {
  public:
    Node () :m_counter(0) {}
    virtual ~Node () {}

    virtual void virtual_function () {
      m_counter += 10;
    }

    void non_virtual_function () {
      m_counter += 1;
    }

    int get_counter () {
      return m_counter;
    }

  private:
    int m_counter;

};

extern "C" {
  JNIEXPORT void JNICALL Java_NodeTester_testNode (JNIEnv *jni_env_rptr, 
                                                   jclass java_class) {
    Node *node_rptr = new Node();
    node_rptr->non_virtual_function();
    node_rptr->virtual_function();

    std::cout << node_rptr->get_counter() << std::endl;

    delete node_rptr;
  }
}

NodeTester.java:

public class NodeTester …

考虑以下代码:

#include <iostream>
using namespace std;

class hello{
public:
    void f(){
        cout<<"f"<<endl;
    }
    virtual void ff(){
        cout<<"ff"<<endl;
    }
};

#define call_mem_fn(object, ptr)  ((object).*(ptr))

template<R (C::*ptr_to_mem)(Args...)> void proxycall(C& obj){
    cout<<"hello"<<endl;
    call_mem_fn(obj, ptr_to_mem)();
}

int main(){
    hello obj;
    proxycall<&hello::f>(obj);
}

当然,这不会在第16行编译,因为编译器不知道是什么R,C并且Args,是.但还有另一个问题:如果有人试图在之前定义这些模板参数ptr_to_mem,他会遇到这种糟糕的情况:

template<typename R, typename C, typename... Args, R (C::*ptr_to_mem)(Args...)> 
                             //  ^variadic template, but not as last parameter!
void proxycall(C& obj){
    cout<<"hello"<<endl;
    call_mem_fn(obj, ptr_to_mem)();
}

int main(){
    hello obj;
    proxycall<void, hello, &hello::f>(obj);
}

令人惊讶的是,g ++没有抱怨 …

我正在做的事情:

我试图将一个矢量分成两个独立的数组.当前int向量包含文本文件中每行的元素.文本文件是随机整数列表.

我打算怎么做:

我目前的想法是创建两个常规int数组,然后迭代整个向量并将n/2个元素复制到每个数组.

我想知道的是:

完成任务的最优雅方式是什么？我有一种感觉,我可以做到这一点,而无需多次迭代矢量.

码:

#include <vector>
#include <fstream>
#include <iterator>
#include <iostream>
using namespace std;

vector<int> ifstream_lines(ifstream& fs)
{
  vector<int> out;
  int temp;
  while(fs >> temp)
  {
    out.push_back(temp);
  }
  return out;
}

vector<int> MergeSort(vector<int>& lines)
{
  int split = lines.size() / 2;
  int arrayA[split];
  int arrayB[split];
}

int main(void) 
{
  ifstream fs("textfile.txt");
  vector<int> lines;
  lines = ifstream_lines(fs);

  return 0;
}

谢谢 :)

如果我有一个C++枚举:

enum Foo
{
  Bar,
  Baz,
  Bork,
};

如何告诉编译器使用a uint16_t来实际存储枚举值？

编辑:GCC在C++ 11的实现中是否支持此功能？

我已经使用OpenGL和C++开展了各种各样的演示项目,但他们都只是简单地渲染一个具有一些有趣效果的立方体(或类似的简单网格).对于像这样的简单场景,立方体的顶点数据可以存储在不优雅的全局数组中.我现在正在研究使用不同类型的多个对象渲染更复杂的场景.

我觉得很有道理,为不同类型的对象(不同类别Rock,Tree,Character,等),但我不知道如何干净地打破了数据和场景中的对象渲染功能.每个类都将存储自己的顶点位置数组,纹理坐标,法线等.但是我不确定在哪里放置OpenGL调用.我想我将有一个循环(在一个World或Scene类中)迭代场景中的所有对象并呈现它们.

渲染它们是否涉及在每个对象中调用一个render方法,(Rock::render(), Tree::render(),...)还是一个以对象作为参数的渲染方法(render(Rock), render(Tree),...)？后者看起来更干净,因为我不会在每个类中都有重复的代码(虽然可以通过从单个RenderableObject类继承来减轻),并且如果我想稍后移植到DirectX,它允许轻松替换render()方法.另一方面,我不确定我是否可以将它们分开,因为我可能还需要存储在对象中的OpenGL特定类型(例如顶点缓冲区).此外,将渲染功能与对象分开似乎有点麻烦,因为它必须调用许多Get()方法来从对象获取数据.最后,我不确定这个系统如何处理必须以不同方式绘制的对象(不同的着色器,传递给着色器的不同变量等).

这些设计中的一个明显优于其他设计吗？在哪些方面我可以改进它们以保持我的代码组织良好和高效？

在开发应用程序时,我遇到了以下问题.我想std::list<string>在给定的函数指针为null时返回空,否则返回该函数的结果.这是我的代码的简化版本:

typedef std::list<std::string> (*ParamGenerator)();

std::list<std::string> foo() {
    /* ... */
    ParamGenerator generator = ...;
    if(generator)
        return generator();
    else
        return {};
}

但是,我通常喜欢?:在这些情况下使用ternary()运算符,所以我尝试这样使用它(像往常一样):

return generator ? generator() : {};

但得到了这个错误:

somefile.cpp:143:46: error: expected primary-expression before ‘{’ token
somefile.cpp:143:46: error: expected ‘;’ before ‘{’ token

这是否意味着我不能使用三元运算符来返回使用其构造函数创建的对象initializer_list？这有什么特别的原因吗？

我使用了很多SSE编译器内在函数编写了一个3D矢量类.一切正常,直到我开始实现具有3D矢量作为新成员的类.我在发布模式下经历了奇怪的崩溃,但在调试模式下却没有,反之亦然.

所以我读了一些文章,并认为我需要将拥有3D矢量类实例的类对齐到16个字节.所以我只是在类之前添加了_MM_ALIGN16(__declspec(align(16)),如下所示:

_MM_ALIGN16 struct Sphere
{
    // ....

    Vector3 point;
    float radius
};

这似乎首先解决了这个问题.但在更改了一些代码后,我的程序又开始以奇怪的方式崩溃.我在网上搜索了一些,发现了一篇博客文章.我尝试了作者Ernst Hot为解决这个问题做了什么,它对我也有用.我在我的类中添加了new和delete运算符,如下所示:

_MM_ALIGN16 struct Sphere
{
    // ....

    void *operator new (unsigned int size)
     { return _mm_malloc(size, 16); }

    void operator delete (void *p)
     { _mm_free(p); }

    Vector3 point;
    float radius
};

恩斯特提到这种方法也可能存在问题,但他只是链接到一个不再存在的论坛,而没有解释为什么它可能会有问题.

所以我的问题是:

1. 定义运算符有什么问题？

2. 为什么不添加_MM_ALIGN16足够的类定义？

3. 处理SSE内在函数的对齐问题的最佳方法是什么？

我可以将a转换Double为CString使用_ecvt

result_str=_ecvt(int,15,&decimal,&sign);

那么,有没有像上面这样的方法转换int为CString？

为什么不能以这种方式获得缓冲区的长度.

AType * pArr = new AType[nVariable];

取消分配相同的数组时

delete [] pArr;

运行时必须知道释放多少.在删除数组之前是否有任何方法可以访问该长度.如果不是,为什么没有提供这样的API来获取长度？