小编Adr*_*thy的帖子

使用STL,我想找到序列中某个值的最后一个实例.

此示例将在int的向量中找到0 的第一个实例.

#include <algorithm>
#include <iterator>
#include <vector>

typedef std::vector<int> intvec;
intvec values;
// ... ints are added to values
intvec::const_iterator split = std::find(values.begin(), values.end(), 0);

现在我可以用split做事的子范围begin().. split和split.. end().我想做类似的事情,但是将split设置为0 的最后一个实例.我的第一个本能就是使用反向迭代器.

intvec::const_iterator split = std::find(values.rbegin(), values.rend(), 0);

这不起作用,因为split它是错误类型的迭代器.所以......

intvec::const_reverse_iterator split = std::find(values.rbegin(), values.rend(), 0);

但现在的问题是我不能使"头"和"尾"范围像begin(), split,split, end()因为那些不是反向迭代器.有没有办法将反向迭代器转换为相应的前向(或随机访问)迭代器？有没有更好的方法来查找序列中元素的最后一个实例,以便我留下兼容的迭代器？

我决定要对特定函数进行基准测试,所以我天真地编写如下代码:

#include <ctime>
#include <iostream>

int SlowCalculation(int input) { ... }

int main() {
    std::cout << "Benchmark running..." << std::endl;
    std::clock_t start = std::clock();
    int answer = SlowCalculation(42);
    std::clock_t stop = std::clock();
    double delta = (stop - start) * 1.0 / CLOCKS_PER_SEC;
    std::cout << "Benchmark took " << delta << " seconds, and the answer was "
              << answer << '.' << std::endl;
    return 0;
}

一位同事指出,我应该声明start和stop变量volatile以避免代码重新排序.他建议优化器可以,例如,有效地重新排序代码,如下所示:

    std::clock_t start = std::clock();
    std::clock_t stop = …

想象一下单词的字母.

例:

 a ==> 1 
 b ==> 2 
 c ==> 3 

 z ==> 26 
 ab ==> 27 
 ac ==> 28 

 az ==> 51 
 bc ==> 52 
 and so on. 

这样字符序列只需要按升序排列(ab有效但ba不是).给定任何单词如果有效则打印其索引,否则打印0.

 Input  Output 

 ab      27 

 ba       0 

 aez     441 

在这个问题中,我可以轻松地做数学,但我没有得到任何算法.

我在数学方面所做的是

一封信26

两封信325

.

.

.

等等

C++的new有一个选项可以返回空指针,而不是在分配失败时抛出bad_alloc异常.

Foo * pf = new(std::nothrow) Foo(1, 2, 3);

(是的,我理解这只会阻止new抛出bad_alloc;它不会阻止Foo的构造函数抛出异常.)

如果你想使用共享指针而不是原始指针,你通常应该使用make_shared,因为它对控制块的分配很聪明.

auto pf = std::make_shared<Foo>(1, 2, 3);

make_shared封装了new,这使得(？)无法选择nothrow版本.因此,您似乎必须放弃make_shared并明确调用new.

std::shared_ptr<Foo> pf(new(std::nothrow) Foo(1, 2, 3));

这消除了使用Foo分配控制块的优化,并且控制块分配可能独立于Foo分配而失败,但我不想关注它.让我们假设控制块很小,所以它的分配在实践中永远不会失败.这是为我担心的Foo分配空间的失败.

有没有办法获得make_shared的单一分配优势,同时保留在为Foo分配空间时简单地获取空指针而不是bad_alloc异常的能力？

我记得曾经看到过使用迭代器将一个完整的二进制文件读入一个向量的巧妙方法.它看起来像这样:

#include <fstream>
#include <ios>
#include <iostream>
#include <vector>

using namespace std;

int main() {
    ifstream source("myfile.dat", ios::in | ios::binary);
    vector<char> data(istream_iterator(source), ???);
    // do stuff with data
    return 0;
}

我们的想法是vector通过传递指定整个流的输入迭代器来使用's iterator范围构造函数.问题是我不确定要为最终迭代器传递什么.

你如何创建istream_iterator一个文件的结尾？我完全记错了这个成语吗？

我正在编程模拟,我想将我的应用程序从使用GDI移植到使用Direct2D.但我的Direct2D代码比我的GDI代码要慢得多.

我在屏幕上渲染了很多椭圆.在我的GDI应用程序中,我绘制到内存设备上下文,然后使用BitBlt在Windows设备上下文中绘制.使用Direct2D,我绘制到ID2D1HwndRenderTarget.

我的问题是,当使用GDI时,我可以轻松绘制400多个椭圆,并且仍然有400 FPS.当我使用Direct2D执行相同数量的省略号时,我的FPS下降到30FPS.

我已经关闭了antialiasing,但它并没有真正帮助.有趣的是,与GDI相比,在Direct2D中绘制几个省略号更快.我可以做些什么来提高Direct2D的性能,还是应该使用GDI保留我的应用程序？

这是我使用GDI的绘图代码:

VOID Begin() {
    SelectObject(this->MemDeviceContext, this->MemoryBitmap);
    this->BackgroundBrush = CreateSolidBrush(this->BackgroundColor);
    HBRUSH OldBrush = (HBRUSH)SelectObject(this->MemDeviceContext, this->BackgroundBrush);
    Rectangle(this->MemDeviceContext, -1, -1, 801, 601);
    SelectObject(this->MemDeviceContext, OldBrush);
    DeleteObject(this->BackgroundBrush);
    SetViewportOrgEx(this->MemDeviceContext, 400, 300, &this->OldOrigin);
}
VOID End() {
    SetViewportOrgEx(this->MemDeviceContext, this->OldOrigin.x, this->OldOrigin.y, 0);
    BitBlt(this->DeviceContext, 0, 0, 800, 600, this->MemDeviceContext, 0, 0, SRCCOPY);
}

在我的Begin和End函数之间,我使用标准的GDI方式绘制省略号.

以下是使用Direct2D的开始和结束函数:

VOID BeginDrawing() {
    this->RenderTarget->BeginDraw();
    RenderTarget->Clear(D2D1::ColorF(D2D1::ColorF::CornflowerBlue));
    RenderTarget->SetTransform(this->ScalingMatrix * this->TranslateMatrix);
}
VOID EndDrawing() {
    this->RenderTarget->EndDraw();
}

以下是我如何设置Direct2D接口.这一切都包括在课堂上; 这就是我无法发布完整代码的原因:

    if(D2D1CreateFactory(D2D1_FACTORY_TYPE_SINGLE_THREADED, &Direct2DFactory) != S_OK)
        throw std::runtime_error("RENDERWINDOW::InitializeDirect2D: Failed to create a factory interface.");
    RECT …

我正在使用128GB内存的服务器来进行一些计算.我需要malloc()一个大小为56120*56120的2D float数组.示例代码如下:

int main(int argc, char const *argv[])
{
    float *ls;
    int num = 56120,i,j;
    ls = (float *)malloc((num * num)*sizeof(float));
    if(ls == NULL){
        cout << "malloc failed !!!" << endl;
        while(1);
    }
    cout << "malloc succeeded ~~~" << endl;
    return 0;
}

代码编译成功,但是当我运行它时,它说"malloc failed !!!".据我计算,只需要大约11GB的内存来容纳整个阵列.在我开始代码之前,我检查了服务器,并且有110GB的可用内存.为什么会发生错误？

我还发现,如果我减少num到40000,那么malloc将会成功.

这是否意味着可以分配的最大内存有限制malloc()？

而且,如果我改变分配方式,直接声明这样大小的2D float数组,如下:

int main(int argc, char const *argv[])
{
    int num = 56120,i,j;
    float ls[3149454400];
    if(ls == NULL){
        cout << "malloc failed !!!" << …

在以下代码中:

int c;
while((c=10)>0)

什么是c = 10评价什么？是1表示值10成功分配给变量c,还是10？为什么？

我正在尝试使用本机Windows消息队列系统(没有.NET)使用C/C++创建一个简单的窗口.我按照MSDN教程编写了一些创建空窗口的基本代码:

void main()
    {
    HINSTANCE hinst;
    HWND hwndMain;
    WNDCLASSEX wnd;
    MSG msg;

    hinst = GetModuleHandle( NULL );
    memset( &wnd, 0, sizeof( wnd ) );
    wnd.cbSize = sizeof( wnd );
    wnd.lpszClassName = "MainWClass";
    wnd.lpfnWndProc = MainWProc;
    wnd.hInstance = hinst;
    int result = RegisterClassEx( &wnd );
    if( !result )
    {
        printf("RegisterClassEx error: %d\r\n", GetLastError() );
    }

    hwndMain = CreateWindowEx
        (
        0, //extended styles
        wnd.lpszClassName, //class name
        "Main Window", //window name
        WS_OVERLAPPEDWINDOW | WS_HSCROLL | WS_VSCROLL | WS_MINIMIZEBOX, //style tags
        CW_USEDEFAULT, //horizontal position …

在Visual C++ 2008 Express中,当我创建一个新的控制台项目时,我得到以下程序:

//Explodey.cpp : Defines the entry point for the console application.

//

#include "stdafx.h"

int _tmain(int argc,_TCHAR* argv[])
{
  return 0;
}

我有几个问题:

• 为什么主函数_tmain而不是main？

• 我认为该argv参数应该是char* argv[]代替_TCHAR.

• 什么stdafx.h？

这并不像我习惯的C++那样.