Micronik's questions

我创建了一个printVector显示任何向量内容的函数（如果分别为它们定义了 << 运算符）：

#include <iostream>
#include <vector>
using namespace std;

template<class templateType>
void printVector(vector<templateType>& container)
{
    for(vector<templateType>::iterator it = container.begin(); it != container.end() ; it++)
    {
        cout << *it<<" ";
    }
    cout << endl;
}


int main()
{
    vector<int> container = { 1,2,3 };
    printVector(container);
}

在定义模板向量时，printVector我无法创建其子类的对象iterator：

vector<templateType>::iterator it; // ERROR

我通过使用解决了这个问题auto：

#include <iostream>
#include <vector>
using namespace std;

template<class templateType>
void printVector(vector<templateType>& container)
{
    for(auto it = container.begin(); it != container.end() ; it++)
    {
        cout << *it<<" ";
    }
    cout << endl;
}


int main()
{
    vector<int> container = { 1,2,3 };
    printVector(container);
}

但是我仍然想知道为什么我不能用它的名字 ( vector<templateType>::iterator) 创建一个子类对象，但我可以用auto?

比通过引用返回本地指针：

#include <iostream>
using namespace std;

int*& foo()
{
    int* pointer = new int{ 10 };
    return pointer;
}

int main()
{
    int* point = foo();
}

与返回此指针的副本不同：

#include <iostream>
using namespace std;

int* foo()
{
    int* pointer = new int{ 10 };
    return pointer;
}

int main()
{
    int* point = foo();
}

该项目有3个文件：

• main.cpp（在其中创建A、B类的对象）
• 类 Ah（A类的实现 + 嵌套在 A 类中的枚举Color的实现）
• Bh 类（B类的实现+嵌套在 B 类中的枚举站点的实现）

项目中有一个问题，A类的Constructor作为参数——B类的一个对象的内存地址，Class[B]的嵌套枚举[Site]的值。它能够接受 B 类对象的内存地址，以及 Class 的嵌套枚举的值

A 类的构造函数能够将指向 B 类对象的指针作为参数，但不能将其嵌套构造（例如，本例中的 enum ）。换句话说，如果您完全删除与嵌套枚举相关的所有内容，则项目将编译。

有没有办法让它像这样：

• A 类是否能够使用（参见）B 类的嵌套枚举（枚举类Site）？
• B 类是否能够使用（参见）A 类的嵌套枚举（枚举类Color）？

有了这一切，A 类和 B 类使用彼此的对象。

// main.cpp

#include "Class A.h"
#include "Class B.h"

int main()
{
    B objB((A*)nullptr, A::Color::Black);
    A objA((B*)nullptr, B::Site::X);
}

// Class A.h

#pragma once

extern class B;

class A
{
public:
    enum class Color
    {
        Red,
        Black
    };

    B* objectB;
    B::Site site;

    A(B* pointB, B::Site site)
    {
        objectB = pointB;
        this->site = site;
    }
};

// Class B.h

#pragma once

extern class A;

class B
{
public:
    enum class Site
    {
        X,
        Y
    };

    A* objectA;
    A::Color color;

    B(A* pointA, A::Color color)
    {
        objectA = pointA;
        this->color = color;
    }
};