我有一个源自的课程CTreeCtrl。在OnCreate()我用CToolTipCtrl自定义对象替换默认对象：
int CMyTreeCtrl::OnCreate(LPCREATESTRUCT lpCreateStruct)
{
if (CTreeCtrl::OnCreate(lpCreateStruct) == -1)
return -1;
// Replace tool tip with our own which will
// ask us for the text to display with a TTN_NEEDTEXT message
CTooltipManager::CreateToolTip(m_pToolTip, this, AFX_TOOLTIP_TYPE_DEFAULT);
m_pToolTip->AddTool(this, LPSTR_TEXTCALLBACK);
SetToolTips(m_pToolTip);
// Update: Added these two lines, which don't help either
m_pToolTip->Activate(TRUE);
EnableToolTips(TRUE);
return 0;
}
我的消息处理程序如下所示：
ON_NOTIFY_EX(TTN_NEEDTEXT, 0, &CMyTreeCtrl::OnTtnNeedText)
但是，我从未收到任何TTN_NEEDTEXT消息。我查看了Spy ++，它看起来也好像从未发送过此消息。
这可能是什么问题？
我不确定这是否相关：CTreeCtrl的父窗口的类型为CDockablePane。可能需要一些额外的工作才能使它正常工作吗？
我想创建一个函数,它可以使用不同类型的迭代器来存储相同类型的对象:
第一个是std::map包含shared_ptr<Foo>(typedef-ed as FooMap),另一个是std::list包含shared_ptr<Foo>(FooList)的.
我非常喜欢MSalters为类似问题提出的解决方案并试图实现boost::variant迭代器,该函数将作为参数从第一个迭代到第二个迭代.
我的函数看起来像这样(简化了很多):
set<Foo> CMyClass::GetUniqueFoos(FooIterator itBegin, FooIterator itEnd)
{
set<Foo> uniques;
for(/**/;
apply_visitor(do_compare(), itBegin, itEnd); // equals "itBegin != itEnd"
apply_visitor(do_increment(), itBegin)) // equals "++itBegin"
{
// Exact mechanism for determining if unique is omitted for clarity
uniques.insert( do_dereference< shared_ptr<Foo> >(), itBegin) );
}
return uniques;
}
FooIterator和访问者定义如下:
typedef
boost::variant<
FooMap::const_iterator,
FooList::const_iterator>
FooIterator;
struct do_compare : boost::static_visitor<bool>
{
bool operator() (
const …在我的MFC(Feature Pack)应用程序中,可以动态创建停靠窗格以显示图表/表格等.
但是,我不想让用户打开相同的东西两次.
我创建一个像这样的窗格:
// Create CMyDockablePane pPane
pPane->Create(...);
pPane->EnableDocking(CBRS_ALIGN_ANY);
// Create CRect rcPane
pPane->FloatPane(rcPane);
这似乎工作正常.
这就是我尝试检查窗格是否已存在的方法.窗格由其类型(类)和参数标识.
BOOL CanOpenPane(const type_info & paneType, const CMyParameter & parameter) const
{
CMainFrame* pFrm = GetMainFrame();
CDockingManager* pDockMan = pFrm->GetDockingManager();
// Check if there already is a pane of the same type which also has the same parameter.
bool canOpen = true;
CObList panes;
pDockMan->GetPaneList(panes);
POSITION pos = panes.GetHeadPosition();
while (pos)
{
CMyDockablePane* pPane = dynamic_cast<CMyDockablePane*>(panes.GetNext(pos));
if (NULL == pPane) { continue; }
if …我有一个类CContainer,它有一些成员CMemberX,CMemberY,这是相互独立和其他的CClientA,CClientB阶级使用CContainer.
#include "MemberX.h"
#include "MemberY.h"
class CContainer
{
public:
CMemberX & GetX() const { return m_x; }
CMemberY & GetY() const { return m_y; }
private:
CMemberX m_x;
CMemberY m_y;
};
我想避免在使用前向声明和动态分配和CClient修改其中一个类时重新编译所有类.CMemberm_xm_y
最初,我做了成员指针:
// Container.h
class CMemberX;
class CMemberY;
class CContainer
{
public:
CContainer();
~CContainer();
CMemberX & GetX() const { ASSERT(m_pX != NULL); return *m_pX; }
CMemberY & GetY() const { ASSERT(m_pY != …我最近重构了这样的代码(MyClassto MyClassR).
#include <iostream>
class SomeMember
{
public:
double m_value;
SomeMember() : m_value(0) {}
SomeMember(int a) : m_value(a) {}
SomeMember(int a, int b)
: m_value(static_cast<double>(a) / 3.14159 +
static_cast<double>(b) / 2.71828)
{}
};
class MyClass
{
public:
SomeMember m_first, m_second, m_third;
MyClass(const bool isUp, const int x, const int y)
{
if (isUp)
{
m_first = SomeMember(x);
m_second = SomeMember(y);
m_third = SomeMember(x, y);
}
else
{
m_first = SomeMember(y);
m_second = SomeMember(x);
m_third = SomeMember(y, x); …只需在代码中略微修改即可计算两个数组的总和
int main()
{
int a[10000]={0}; //initialize something
int b[10000]={0}; //initialize something
int sumA=0, sumB=0;
for(int i=0; i<10000; i++)
{
sumA += a[i];
sumB += b[i];
}
printf("%d %d",sumA,sumB);
}
要么
int main()
{
int a[10000]={0}; //initialize something
int b[10000]={0}; //initialize something
int sumA=0, sumB=0;
for(int i=0; i<10000; i++)
{
sumA += a[i];
}
for(int i=0; i<10000; i++)
{
sumB += b[i];
}
printf("%d %d",sumA,sumB);
}
哪个代码会更快.
我们有一些专门开发的C++应用程序,仅适用于Debian stable(x86).
目前,这些应用程序的开发也是使用Debian stable(x86)系统完成的,因此开发人员拥有与目标系统相同的库版本.
偶尔,我还需要处理这些组件,并且一直困扰我,因为我坚持使用非常过时的KDevelop版本(4.0.1与最新的4.4.1).我想使用更新的系统进行开发(比如最新的Ubuntu或Debian测试),但是如何创建适合目标系统的二进制文件呢？
是否有一些简单的方法可以告诉编译器/链接器只使用目标平台上可用的库版本？
我看了Emdebian和他们的交叉编译包,但我不认为这对我有用.他们似乎只有针对ARM等其他架构的软件包.
我是错误"LNK1179:无效或损坏的文件:重复COMDAT"的受害者,这些 来源让我相信,通过不使用phoenix我可以避免此错误.
(这是我之前的问题的后续行动.)我想boost::phoenix用其他东西替换.也许,boost::bind但我不知道如何让它访问karma::_val.
以下代码无法在VC9上编译
错误C2825:'F':当后跟'::'时必须是类或命名空间
#include <boost/config/warning_disable.hpp>
#include <boost/foreach.hpp>
#include <boost/assign/list_of.hpp>
#include <boost/range/adaptors.hpp>
#include <boost/range/algorithm.hpp>
#include <boost/spirit/include/qi.hpp>
#include <boost/spirit/include/karma.hpp>
#include <boost/spirit/include/phoenix.hpp>
#include <boost/bind.hpp>
#include <iostream>
#include <string>
#include <list>
namespace karma = boost::spirit::karma;
namespace spirit = boost::spirit;
namespace ascii = boost::spirit::ascii;
namespace phoenix = boost::phoenix;
class Item
{
public:
typedef std::vector<int> Values;
Item(const std::string & i, const Values & v) : m_id(i), m_values(v) {}
std::string getId() const { …Java应用程序是否可能比用C++编写的程序更快？另外,编译中的发布模式是什么？
我创建了一个CMyClassCTor采用UCHARas参数的类.该参数可以具有各种枚举的值(都保证适合a UCHAR).我需要转换这些值,UCHAR因为库函数要求其参数作为该类型.
我必须创建很多这些消息对象并节省我使用的打字工作boost::assign:
std::vector<CMyClass> myObjects;
boost::assign::push_back(myObjects)
(MemberOfSomeEnum)
(MemberOfSomeEnum);
std::vector<CMyClass> myOtherObjects;
boost::assign::push_back(myObjects)
(MemberOfAnotherEnum)
(MemberOfAnotherEnum);
上面的代码CMessage用两个枚举成员中的每一个调用CTor,然后将它们放在一个列表中.我的问题是,这段代码在VC++ 9上抛出警告C4244(在从枚举转换为UCHAR期间可能丢失数据).
我目前的解决方案是为每个枚举类型创建一个转换函数:
static UCHAR ToUchar(const SomeEnum eType)
{
return static_cast<UCHAR>(eType);
}
static UCHAR ToUchar(const AnotherEnum eType)
{
return static_cast<UCHAR>(eType);
}
然后上面的代码如下所示:
std::vector<CMyClass> myObjects;
boost::assign::push_back(myObjects)
(ToUchar(MemberOfSomeEnum))
(ToUchar(MemberOfSomeEnum));
std::vector<CMyClass> myOtherObjects;
boost::assign::push_back(myObjects)
(ToUchar(MemberOfAnotherEnum))
(ToUchar(MemberOfAnotherEnum));
这是迄今为止我能想到的最干净的方法.
有没有更好的方法？
也许boost有一些不错的东西可供选择？
我不想用pragma语句禁用警告,我无法修改枚举.
这两种情况之间的速度是否存在明显差异？
场景1:我有一个大小为1024字节的文件,每个字节都填充0.我打开文件,用fwrite写入1024字节的1s.
场景2:我有一个大小为512字节的文件,每个字节都填充0.我打开文件,用fwrite写入1024字节的1s.
显然我最终得到了相同的文件,但在调整磁盘上的第二个文件时是否有任何损失？
我正在尝试确定在使用它们之前调整文件大小是否有任何价值.奖励指向任何能够向我展示一些Linux文档以证明这一点的人.