小编SSi*_*ht3的帖子

子类是否继承,主类的朋友关联(主类'自己和其他类与主类相关)？

或者换句话说,继承如何应用于friend关键字？

扩展:如果没有,有没有办法继承友谊？

我遵循Jon的建议来提出设计问题:
C++类设计问题

鉴于以下功能:

freopen("file.txt","w",stdout);

将stdout重定向到一个文件,如何将它重新定向到控制台？

我会注意到,是的还有其他类似的问题,但它们是关于linux/posix的.我正在使用Windows.

您无法分配给stdout,这会使依赖它的一组解决方案无效.dup和dup2()不是Windows的原生,使另一组无效.如上所述,posix函数不适用(除非你计算fdopen()).

一个简单的问题:

如何检查已打开文件指针的访问模式？

所以说一个函数传递已经打开的FILE指针:

    //Pseudo code
    bool PseudoFunction(FILE *Ptr)
    {
        if( ... Insert check for read-only access rights )
        {
            //It's read only access mode
            return true;
        }
       //File pointer is not read-only and thus write operations are permitted
       return false;
    }

我将在if语句中使用什么来检查FILE指针是否为只读(或不是,视情况而定),而不是写入文件,而不依赖于用户传递(可能是矛盾的)参数？

系统是windows,code :: blocks编译器,但为了代码的可移植性,交叉兼容性是首选.

注意,这不是询问文件权限,而是FILE指针使用了什么访问模式.

SELF-ANSWER [由于用户权限限制,无法附加单独的答案]:

下面的另一张海报有一个更好的答案,包括正确的#defines

如前所述,看起来FILE指针的_flag(在_iobuf下定义)是知道文件是否只读的关键.您的里程可能会有所不同,但相同的基本概念应该很容易适应,示例代码:

#define READ_ONLY_FLAG 1

bool PrintFlagPtr(const char FileName[], const char AccessMode[])
{
    FILE *Ptr = NULL;
    Ptr = fopen(FileName,AccessMode);
    printf("%s: %d ",AccessMode,Ptr->_flag);

    int IsReadOnly = Ptr->_flag;
    fclose(Ptr);
    Ptr = NULL;


    if( …

在C或C++中,显然可以限制变量的位数,例如:

unsigned char A:1;
unsigned char B:3;

我不熟悉它的具体工作原理,所以有很多问题:

如果我有一个包含以下变量的类:

unsigned char A:1;
unsigned char B:3;
unsigned char C:1;
unsigned char D:3;

1. 实际上叫什么上面的技术？
2. 是高于类四个字节,还是一个字节大小？
3. 这些变量是如图所示被视为1(或3)位,还是按照'unsigned char'被视为每个字节？
4. 有没有将这些位组合成一个集中字节？例如:

.

unsigned char MainByte;
unsigned char A:1; //Can this be made to point at the first bit in MainByte?
unsigned char B:3; //Etc etc
unsigned char C:1;
unsigned char D:3;

1. 是否有一篇文章更深入地介绍了这一主题？
2. 如果'A:1'被视为整个字节,它的点/紫色是什么？

随意提及任何其他考虑因素(如编译器限制或其他限制).

谢谢.

如果我有下面给出的类:

class TestA
{
    public:
        const TestA &operator=(const int A){return *this;}
};

class TestB : public TestA
{
    public:
        //Inheritance?
};

这个问题假设TestA类和TestB类在变量方面具有完全相同的内容:赋值运算符(或任何其他运算符)是否继承？

以下是否有效？

class TestB : public TestA
{
    public:
        using TestA::operator=;
        //Inheritance?
};

如果它有效,它会有所作为吗？

鉴于以下类在两个单独的头文件中,并且可以按任何顺序出现:

//TestB.h
class TestB; //Forward declaration for a later operator= in a centralised header

class TestA
{
    const TestA&operator=(const TestB); //defined in Test.h
};

和:

//TestA.h
class TestA; //Forward declaration for a later operator= in a centralised heaer

class TestB
{
    const TestB&operator=(const TestA); //defined in Test.h
};

我如何避免原型冲突？

感谢帮助.

我绝对向大家道歉!我原本打算在那里引用(运算符中的&符号=参数 - 我永远不会通过复制条形简单的POD)并且只是关于原型冲突的问题!我想它会证明校对的重要性!鉴于原始(我的错误)背景,我接受了答案.

我只是转了几分钟,并没有意识到错!

我如何制作它以便以下代码在课外进行外部化:

template<typename TemplateItem>
class TestA
{
     operator const int (){return 10;}
};

所以看起来像:

template<typename TemplateItem>
class TestA
{
    operator const int ();
};

template<>
TestA<int>::operator const int()
{
    //etc etc
}

所以我可以专门针对不同模板类型的函数？

给出以下代码:

class TestA
{
    private:
        char Temp;

    public:
        char *Ptr;

        TestA(){Ptr = NULL; Temp = 'A'; Ptr = &Temp;}
        void Function(){Ptr = &Temp; Temp = 'B';}

        void operator=(const TestA &ItemCopy)
        {
            //ItemCopy.Temp = 'N'; //Not permitted
            printf("%c!\n",ItemCopy.Temp);
            Ptr = ItemCopy.Ptr; //This is okay
            *Ptr = 'M'; //This is okay, but it re-assigns ItemCopy.Temp. What?
            printf("%c!\n",ItemCopy.Temp);
        }
};

int main()
{
    TestA Temp1,Temp2;

    Temp1.Function();
    Temp2 = Temp1;
}

产生以下内容:

B
M.

即使ItemCopy是常量.为什么我被允许间接修改它甚至采用指针的非常量副本？

可能重复:
#include任何地方

对于相应的语言,以下是有效的(可接受的编程实践):

#include "SomeHeader.h"
#include "HeaderDefs.h" //Includes #defines (like CONST_VAR)

void Function1(){;}
void Function2(){;} //etc
//Additionally:
void Function3(){while(1){
  #include "Files.h"
  ;
}} //Result?    

#include "HeaderUndefs.h" //Includes #undef (like undef CONST_VAR)

从以下扩展评论:

我扩大了.请记住它是'有效性'而不是'它会编译'.我相信它可以编译,但Stack Overflow提供了深入探索的见解(如Daniel Wagner).我可以有一个#includes的while循环吗？(或者这会破坏惯例...... #includes任何地方 - 它们也有效吗？).

在编写响应时,我编写了一些代码来挑战我对const指针如何工作的假设.我假设删除函数无法删除const指针,但正如您将从下面的代码中看到的那样,情况并非如此:

#include <new>
#include <string.h>

class TestA
{
    private:
        char *Array;
    public:
        TestA(){Array = NULL; Array = new (std::nothrow) char[20]; if(Array != NULL){ strcpy(Array,"Input data"); } }
        ~TestA(){if(Array != NULL){ delete [] Array;} }

        char * const GetArray(){ return Array; }
};

int main()
{
    TestA Temp;
    printf("%s\n",Temp.GetArray());
    Temp.GetArray()[0] = ' '; //You can still modify the chars in the array, user has access
    Temp.GetArray()[1] = ' '; 
    printf("%s\n",Temp.GetArray());
    //Temp.GetArray() = NULL //This doesn't work

    delete [] Temp.GetArray(); //This works?! …