小编qua*_*dev的帖子

我有一个类方法返回对某事物的引用.当我使用这个方法时,如果我只有这个东西的前向声明,我只能编译,如果我分配方法的输出.我真的不明白为什么......

这是一个简化的例子:

ClassA.h:

//Forward declare
class ClassB;

class ClassA
{
public:
    ClassA(void);
    ~ClassA(void);

    ClassB& Func();
};

ClassA.cpp:

#include "ClassA.h"

#include "ClassB.h"

ClassA::ClassA(void)
{}

ClassA::~ClassA(void)
{}

static ClassB c;

ClassB& ClassA::Func()
{
    return c;
}

ClassB.h:

#pragma once
class ClassB
{
public:
    ClassB(void) {};
    ~ClassB(void) {};
};

现在,如果我在ClassA::Func没有分配返回值的情况下调用(虽然只有前向声明ClassB),它将无法编译:

main.cpp中:

#include "ClassA.h"

int main(void)
{
    ClassA a;

    a.Func(); //error C2027: use of undefined type 'ClassB'

    return 0;
}

如果我改用这一行,它的工作原理是: ClassB& b = a.Func();

这里发生了什么事？ClassB当没有在任何地方分配返回值时,为什么编译器需要知道其方法的大小或方法？

我正在用VisualStudio 2010 …

我试图看到为什么在C++ 11中,他们必须override在方法的末尾而不是像开头那样添加关键字virtual.我不明白的是能够写出两种利益virtual,并override在方法的声明.

有没有技术上的原因,为什么委员会不选择简单地写作override而不是virtual在需要时？

谢谢!

假设我有一个返回a的函数std::string.某些情况意味着字符串没有填充任何内容.

返回std::string()完全等同于std::string("")？例如,将c_str()或data()给你同样的字符序列？也许std::string("")调用一个简短的字符串优化,但std::string()在添加一些字符之前不会这样做.

有谁知道当前的标准(C++ 11)是否说明了什么？

我想知道是否有一种优雅的方式或内置函数可以转换vector<double>为vector<string>.我所做的很简单

#include <iostream>
#include <string>
#include <vector>
#include <sstream>


std::vector<std::string> doubeVecToStr(const std::vector<double>& vec)
{
    std::vector<std::string> tempStr;

    for (unsigned int i(0); i < vec.size(); ++i){
        std::ostringstream doubleStr;
        doubleStr << vec[i];    
        tempStr.push_back(doubleStr.str());
    }

    return tempStr;
}


int main( int argc, char* argv[] )
{
    std::vector<double> doubleVec;
    doubleVec.push_back(1.0);
    doubleVec.push_back(2.1);
    doubleVec.push_back(3.2);

    std::vector<std::string> doubleStr;
    doubleStr = doubeVecToStr(doubleVec);

    for (unsigned int i(0); i < doubleStr.size(); ++i)
        std::cout << doubleStr[i] << "  ";

    std::cout << std::endl;

    return 0;
}

#include <iostream>

template<typename Impl>
struct renderer{
    void get(){
        static_cast<Impl*>(this)->get();
    }
};
struct open_gl : public renderer<open_gl>{
    void get(){
        std::cout << "OpenGL" << std::endl;
    }
};
struct direct_draw : public renderer<direct_draw>{
    void get(){
        std::cout << "DX" << std::endl;
    }
};
template<typename T>
void print_renderer(renderer<T> r){
    r.get();
}
int main() {
    auto gl = open_gl();
    auto dx = direct_draw();
    print_renderer(gl);
    print_renderer(dx);
}

1. 为什么我不能将print_renderer的参数更改为void print_renderer(const renderer<T> &r)？ cannot convert 'this' pointer from 'const renderer<open_gl>' to 'renderer<open_gl> &' `

2. 当我将getopen_gl中的方法从get …

我正在寻找一种方法来提供一个带模板(STL)容器的函数,但需要它的元素是某种类型(例如int).

这些函数调用应该是VALID:

std::vector<int> Argument;
void foo( Argument );

std::list<int> Argument
void foo( Argument );

std::deque<int> Argument
void foo( Argument );

...etc

这些函数调用应该是INVALID:

std::vector<float> Argument;
void foo( Argument );

std::list<double> Argument
void foo( Argument );

std::deque<char> Argument
void foo( Argument );

...etc

有没有办法模板"foo",以便int接受容器,但不接受具有不同元素类型的容器？

最好,本

假设我在'i'位置插入p个新元素std::vector<mytype>,大小为'n'.

由于物品std::vector保证为其元素使用连续的存储位置,看起来我需要4步才能完成上述操作:

1)如果我们空间不足,可能会重新分配矢量,基本上会使其大小加倍.但这是一个恒定的时间操作(尽管是一个非常大的操作).

2)接下来是从旧向量到新向量的索引0到i-1的元素的memcpy.

3)然后复制在第i个索引处插入的'p'个新项目.

4)然后另一个memcpy用于从旧向量到新向量的i + 1到n索引的所有项目.

是不是所有上述恒定时间操作？那么不应该插入自己的恒定时间操作？那么为什么std::vector::insert插入的元素数量(复制/移动结构)加上位置(移动)后的元素数量是线性的？

class armon
{
    static const int maxSize=10;    

    int array[maxSize];

    int count=0;

    int* topOfStack=array;
}

为什么maxSize需要static在数组中使用它？

#include "booking.h"
#include <iostream>
booking::booking (  const std::string p_title,  const std::string p_notice,  const category p_category,  const person p_person,  const booking::Type p_type,  const double p_value ) :
m_type{ p_type },
m_title{ p_title },
m_notice{ p_notice },
m_person{ p_person },
m_category{ p_category },
m_value { p_value }
{
    std::cout << "Booking was created" << std::endl; // Debug Message
}

这些是文件（我认为必须知道的所有内容）

#pragma once
#include <string>
#include "person.h"
#include "category.h"
class booking
{
public:
    enum Type { TYPE_REVENUE, TYPE_EXPENDITURE };
    booking ( const std::string …

std::string pop_back() :删除字符串的最后一个元素

在C++规范中,据说C++ 11字符串类函数pop_back具有恒定的时间复杂度.

(更确切地说 - 未指定但通常不变)

http://www.cplusplus.com/reference/string/string/pop_back/

除此之外,我阅读了C++ 11规范的草案,据说它pop_back等于str.erase(str.length() -1).据我所知,擦除功能只需分配一个新的内存量,并将剩余的元素(未删除)复制到此内存中,这将占用线性时间.鉴于此,pop_back如何在恒定时间内完成.