标签: c++03

假设我有一个功能模板StrCompare

template<typename T=NonCaseSenCompare>//NonCaseSenCompare is a user defined class look at the detailed code below.
int StrCompare(char* str1, char* str2)
{
...
}

现在在主要功能我写了一行

char* str1="Zia";
char* str2="zia";
int result=StrCompare(str1,str2);

它应该工作,因为我们提供了一个默认的模板参数,但它 没有
编译器给出以下错误
没有匹配函数调用`StrCompare(char*&,char*&)'现在详细的代码由下面给出

#include<iostream.h>
class CaseSenCompare
{
public: 
static int isEqual(char x, char y)
{
return x==y;
}
};
class NonCaseSenCompare
{
public:
static int isEqual(char x,char y)
{
char char1=toupper(x);
char char2=toupper(y);
return char1==char2;
}
};
template<typename T=NonCaseSenCompare>
int StrCompare(char* str1, char* str2)
{
for(int i=0;i < strlen(str1)&& strlen(str2);i++) …

让我说我有

struct Value { int foo(); };
size_t *begin = ...,
       *end   = ...;

如果我想Value在C++ 03中对一堆索引进行排序,我必须写一些像这样乏味的东西:

struct Comparator
{
    Value *data;
    Comparator(Value *data) : data(data) { }
    bool operator()(size_t a, size_t b)
    { return data[a].foo() < data[b].foo(); }
};
sort(begin, end, Comparator(data));

有没有办法用Boost(可能是Boost.Lambda)更整齐地写出这个,最好是一行？

我试图创建一个单身时想出了这个.示例:(我正在尝试创建MySelf一个单例,它是线程安全的,不使用双重检查锁定)

class MySelf
{
private:
    string Name;
    int Age;

    MySelf()
    {
        Name = "Deamonpog";
        Age = 24;
        cout << "Constructing MySelf : " << Name << endl;
    };

    friend class MySingleton;

public:
    ~MySelf(){ cout << "Destructing MySelf : " << Name << endl; };

    int MyAge() const
    {
        return Age;
    }
};

class MySingleton
{
private:
    static MySelf mself;
public:
    static MySelf * GetInstance()
    {
        return &mself;
    }
};

MySelf MySingleton::mself;

现在我可以很容易地使用它,像

cout << "I am " << …

未声明(自动生成)的复制构造函数是否自动标记为inline？

如果是这样,如果我不希望它们被标记为inline,这是否意味着我必须手动定义一个并手动复制我需要的每个成员(假设我没有使用C++ 11,所以没有= default从中获利)？

首先,如果这是一个令人眼花缭乱的简单而明显的问题,我想道歉.我知道对于拥有专业知识的人来说,这是一件相当容易的事情.C++ 11允许以列表形式初始化向量:

std::vector<std::string> v = {
    "this is a",
    "list of strings",
    "which are going",
    "to be stored",
    "in a vector"};

但这在旧版本中不可用.我一直在努力想出填充字符串向量的最佳方法,到目前为止我唯一能想到的就是:

std::string s1("this is a");
std::string s2("list of strings");
std::string s3("which are going");
std::string s4("to be stored");
std::string s5("in a vector");

std::vector<std::string> v;
v.push_back(s1);
v.push_back(s2);
v.push_back(s3);
v.push_back(s4);
v.push_back(s5);

它有效,但写作有点苦差事,我相信有更好的方法.

在急速的时刻,需要一个指向对象的指针传递给一个函数.我拿了一个未命名的临时对象的地址,令我惊讶的是它编译了(原始代码的警告进一步向下,缺少下面例子中的const正确性).好奇,我设置了一个受控制的环境,一直有警告,并将警告视为Visual Studio 2013中的错误.

请考虑以下代码:

class Contrived {
  int something;
};

int main() {
  const Contrived &r  = Contrived();                    // this is well defined even in C++03, the object lives until r goes out of scope
  const Contrived *p1 = &r;                             // compiles fine, given the type of r this should be fine. But is it considering r was initialized with an rvalue?
  const Contrived *p2 = &(const Contrived&)Contrived(); // this is handy when calling functions, is it valid? It also …

标签会提出问题,但考虑以下因素:

template<typename F, typename A, typename R>
R call(F function, A arg) {
    return function(arg);
}

int foo(char) {
    return 5;
}

int main() {
    call(foo, 'a');
}

如果删除参数R并且手动插入int作为返回类型,编译器会愉快地编译它.如图所示,编译器无法知道如何制作R.

如何在C++ 03中推断出函数返回类型？

我正在寻找不需要手动指定返回类型的方法,也不需要对其他参数进行侵入式更改.如果这是不可能的,那么我只是在寻找一个权威声明来验证这一点.

C++ 11通过允许您使用"= delete"语法将隐式编译器定义的方法标记为verboten来解决长期困扰我的问题. 维基百科了解更多信息.

class Foo
{
public:
     Foo();
    ~Foo();

    // No copy
    Foo(Foo const &) = delete;
    Foo& operator=(Foo const &) = delete;
};

我不希望复制或分配的类的复制和赋值运算符总是很难搞乱.这是一个很大的锅炉板代码,使它们成为私有的,然后通常会有成员数据,没有一个默认的构造函数,需要一些挥手让编译器对你想要没有人调用的函数感到高兴.

class Bar
{
public:
   explicit Bar(UniqueResourceID id): m_data(id) { }
   ~Bar();

protected:
   SomeHandle  m_data; // no default constructor

// all this crap to keep from being able to copy.  Do not use any of these!!
private:
   Bar() { } // ERROR: m_data has no default constructor
   static UniqueResourceID s_invalidID; // now I'm making the …

我有下面的代码

template<typename U, typename F >
U GetListAndSearchName( F listGetter, const std::string& stringName )
{
    std::vector<UserType> newList;
    for ( size_t i = 0; i < myList.size(); i++)
    {
        const std::vector<U>& list = listGetter(myList[i]);
        for ( size_t i = 0; i < list.size(); i++ )
        {
            if ( list[i]->GetName() == stringName )
                return list[i];
        }
    }
    return U();
}

甚至U存在于我的函数指针的返回类型中,它是模板参数F(我以后使用std :: mem_fn来创建它可能也是std :: function)当前我需要显式地将U的类型传递给编译器.

如何让我的旧Vs2010编译器推断出U的类型？

问题很简单-什么是C ++ 11之前的C ++中简单易用的互斥解决方案？我不需要花哨的东西-只需一点代码即可在执行之前等待另一个回调（可能随时发生）完成。

我正在您的日常PC，i7和其他设备上运行。没有特定的性能要求（不会太慢），但是必须完成停止一个进程的工作，让另一个进程完成，然后恢复第一个进程。

提前致谢 ！