小编hkB*_*sai的帖子

在速度,性能和机器代码大小方面哪种格式更好？

最后return封装:

static bool MyClass::IsEqual(int A, int B)
{
    if (A == B)
    {
        return true;
    } 
    else
    {
        return false;
    }
}

最后return没有封装:

static bool MyClass::IsEqual(int A, int B)
{
    if (A == B)
    {
        return true;
    }
    return false;
}

这是基类:

template <class T>
class DataLogger
{
        // ...
    public:
        void AddData(T Data);
        // ...
}

这是派生类:

#include "DataLogger.h"
#include <utility>

class Plotter : public DataLogger<std::pair<long double, long double>>
{
        // ...
    public:
        void AddData(long double x, long double y);
        // ...
}

// This method is supposed to wrap the original AddData() method
// which was defined in the base class
void Plotter::AddData(long double x, long double y)
{
    AddData(std::make_pair(x, y));  // LINE #29
}

给定的错误是:

第29行:IntelliSense:没有合适的从"std :: pair"到"long …

我的目标是从另一个PHP文件中定义的全局数组中检索一些数据.我的代码在"database.php"文件中运行,我想要使用的数组在"config.php"文件中.

我的代码如下:

config.php文件

$CONFIG = array();
// ...
$CONFIG["DATABASE"] = array();
$CONFIG["DATABASE"]["USERNAME"] = "user";
$CONFIG["DATABASE"]["PASSWORD"] = "pass";
$CONFIG["DATABASE"]["HOSTNAME"] = "127.0.0.1";
$CONFIG["DATABASE"]["DATABASE"] = "my_db";
// ...

为database.php

require('config.php');

class Database
{
    protected   $m_Link;
    private     $m_User;
    private     $m_Pass;
    private     $m_Host;
    private     $m_Data;
    private     $m_bConnected;

    public function __construct()
    {
        global $CONFIG;
        $this->m_User = $CONFIG["DATABASE"}["USERNAME"]; // Line #16
        $this->m_Pass = $CONFIG["DATABASE"}["PASSWORD"];
        $this->m_Host = $CONFIG["DATABASE"}["HOSTNAME"];
        $this->m_Data = $CONFIG["DATABASE"}["DATABASE"];
        $this->m_bConnected = false;
        $this->Connect();
    }

    // ...
};

给出的错误是:

解析错误:语法错误,意外'}',期待']'在第16行的C:...\database.php中

我无法弄清楚我在这里做错了什么.

请帮我修复此错误.

(注意:PHP版本是5.3.0)

我的代码如下:

Interpolation.h

#ifndef INTERPOLATOR
#define INTERPOLATOR

#include <vector>
#include <utility>

template <class T>
class Interpolator
{
    public:
        static T InterpolateVector(const std::vector<std::pair<T, T>> & Vector, T At);

    private:
        static T GetBasisValue(T x);
};

template <class T>
T Interpolator::InterpolateVector(const std::vector<std::pair<T, T>> & Vector, T At) // Line #22
{
    // ...
}   // Line #25

// ...

#endif  // INTERPOLATOR

main.cpp中

#include <vector>
#include <utility>
#include "Interpolator.h"

int wmain(int argc, wchar_t *argv[])
{
    std::vector<std::pair<float, float>> Measurements;
    Measurements.push_back(std::make_pair(0, 80.8));
    Measurements.push_back(std::make_pair(1, 80.4));
    Measurements.push_back(std::make_pair(3, 80.1)); …

如果两者都给出相同的结果,我应该更喜欢+(加法)运算符还是|(或)运算符？

我知道添加和逻辑OR是不同的东西.但它们有时会在某些宏中执行相同的操作,尤其是在使用字节和位时.在这种情况下我应该选择哪一个？

例:

uint8_t Byte1 = 0x02;   // 0000 0010
uint8_t Byte2 = 0x80;   // 1000 0000
uint16_t Word1, Word2;  // 0000 0010 1000 0000 = 640 = 0x0280

Word1 = (Byte1 << 8) + Byte2;
Word2 = (Byte1 << 8) | Byte2;

std::cout << "Word1 = " << Word1 << std::endl;
std::cout << "Word2 = " << Word2 << std::endl;

输出:

Word1 = 640
Word2 = 640

我在代码中定义了自己的字符串类型.

typedef wchar_t CharType;
typedef std::basic_string<CharType> StringType;

我有一个静态类(它没有实例),它将在屏幕上打印字符串消息.我决定放一个COUT静态成员,它将引用std::cout或std::wcout根据我定义的字符串类型.

标题:

#include <ostream>

class MyTestClass
{
    public:
        // ...
        static std::basic_ostream<CharType> & COUT;
        // ...
}

CPP:

std::basic_ostream<CharType> & MyTestClass::COUT = /* How do I initialize this? */;

有没有办法初始化这个静态成员COUT？

“参考角”的定义：

一个角度？_r在区间 [0, 2?) 对应的角度 ? 在这个区间之外，满足条件
sin(?) = sin(? _r ) 和 cos(?) = cos(? _r )。

例如（为简单起见，以度为单位考虑）：

ref(390 ^o ) = 30 ^o
ref(360 ^o ) = 0 ^o
ref(-40 ^o ) = 320 ^o
ref(540 ^o ) = 180 ^o

查找参考角度的示例代码是：

double FindReferenceAngle(double Angle)
{
    const double TWOPI = 2.0 * 3.1415926535897932384626433832795;
    while(true)
    {
        if (Angle >= TWOPI)
        {
            Angle -= TWOPI;
        }
        else if (Angle < 0)
        {
            Angle += TWOPI;
        }
        else
        { …

class MyClass
{
    public:
        enum ErrorCodes
        {
            ERR_SUCCESS     = 1,
            ERR_READ        = 2,
            ERR_WRITE       = 3,
            // ...
            ERR_ALLOCATE    = 99,
            ERR_DELETE      = 100
        };

        ErrorCodes DoSomething();
};

MyClass::ErrorCodes MyClass::DoSomething()
{
    // ...
    return ErrorCodes::ERR_SUCCESS;
}

在我的示例代码中有一个非常长的enum定义,其中包含100个变量.假设每个变量保存4个字节的内存,enum则将使用400个字节的内存.一旦我开始创建这个类的对象会发生什么？因此,每个对象是否会消耗额外的400字节内存enum,或者是否会在此类的enum所有对象之间共享,因此无论初始化的类实例数是多少,都将使用仅固定的400字节？

如果要为每个实例使用400字节的内存,在这种情况下我可以使用哪种替代方法？

据我所知,const int *暗示我可以改变指针而不是数据,int * const说我不能改变指针地址,但我可以改变数据,并const int * const声明我不能改变它们中的任何一个.

但是,我无法更改使用该类型定义的指针的地址const int *.这是我的示例代码:

void Func(const int * pInt)
{
    static int Int = 0;
    pInt = ∬
    Int++;
}

int wmain(int argc, wchar_t *argv[])
{
    int Dummy = 0;
    const int * pInt = &Dummy;
    //const int * pInt = nullptr;   // Gives error when I try to pass it to Func().
    std::cout << pInt << '\t' << *pInt << std::endl;
    std::cout << "-------------------" …

如果我有一个窗口的句柄,比方说hWnd,我可以得到它的字体类型的句柄,比如说hFont,像这样:

HFONT hFont = SendMessage(hWnd, WM_GETFONT, NULL, NULL);

在此之后,如何LOGFONT从此HFONT句柄获取结构(包含字体的许多功能)？

我的目的不是通过调用从头开始创建字体CreateFont().我想将字体属性读入一个LOGFONT结构,然后随意修改它,最后通过调用该CreateFontIndirect()函数并将修改后的LOGFONT对象传递给它来更新字体.

我该怎么做呢？