相同模板类但不同模板类型的受保护成员
是指在C++编程语言中，使用模板类创建的不同类型的对象，这些对象可以访问模板类中的受保护成员。
模板类是一种通用的类模板，可以根据不同的类型参数来生成具体的类。在模板类中，可以定义公共成员、私有成员和受保护成员。公共成员可以被任何地方的代码访问，私有成员只能在类内部访问，而受保护成员可以在类内部和派生类中访问。
不同模板类型的受保护成员具有相同的模板类结构，但其访问权限不同。派生类可以继承模板类，并且可以访问模板类中的受保护成员。这样，通过创建不同类型的派生类对象，可以访问相同模板类但不同模板类型的受保护成员。
以下是一个示例代码：
template <typename T>
class TemplateClass {
protected:
T protectedMember;
public:
// 公共成员和其他成员的定义
};
class DerivedClass : public TemplateClass<int> {
public:
void accessProtectedMember() {
protectedMember = 10; // 可以访问受保护成员
}
};
int main() {
DerivedClass obj;
obj.accessProtectedMember();
return 0;
}在上面的示例中，TemplateClass是一个模板类，其中有一个受保护成员protectedMember。DerivedClass是TemplateClass的派生类，可以访问受保护成员protectedMember。
这种使用模板类创建不同类型对象的方式可以提高代码的重用性和灵活性。通过使用不同的模板参数，可以在不修改模板类代码的情况下，创建适用于不同类型的对象，并且可以访问相同模板类但不同模板类型的受保护成员。
腾讯云相关产品和产品介绍链接地址：
- 腾讯云云服务器（CVM）：https://cloud.tencent.com/product/cvm
- 腾讯云云数据库MySQL版：https://cloud.tencent.com/product/cdb_mysql
- 腾讯云对象存储（COS）：https://cloud.tencent.com/product/cos
- 腾讯云人工智能：https://cloud.tencent.com/product/ai
- 腾讯云物联网平台：https://cloud.tencent.com/product/iotexplorer
相关·内容
3回答
无法访问同一类的私有成员。
、、、、
我正在实现一个智能指针类作为一个摘录。请考虑以下几点：
class Base1 {
protected:
Base1() : derived_destructor_called(false) {
printf("Base1::Base1()\n");
}
private:
Base1(const Base1 &); // Disallow.
Base1 &operator=(const Base1 &); // Disallow.
protec
浏览 3提问于2013-04-10得票数 1
回答已采纳
在以下代码()中：
#include <utility>
struct Friend {
class Inner {
friend struct Friend;
int function() { return 0; }
};
using DirectResult = decltype(std::declval<Inner>().function());
template <typename T>
using IndirectResult = decltype(std::declv
浏览 0提问于2020-04-24得票数 6
回答已采纳
不幸的是，我主要在Java上下文中学习了类设计和设计模式；因此，有时我很难将熟悉的模式转换为C++。
假设我们希望有一个基类，它的功能由一个子类扩展。在Java中，我们会这样做：
public class BaseClass<T> {
//T is used here
protected int foo = 0;
}
public class DerivedClass<T> extends BaseClass<T> {
public void incr_foo() {
++foo;
}
浏览 6提问于2014-04-30得票数 4
回答已采纳
我正在为我的任务输入代码，我需要在模拟文件中创建两个队列，即客户队列和服务器队列，这两个队列是问题中所要求的动态队列
我不知道我是需要在模拟头文件中创建一个新的队列类型，还是只需要使用相同的头文件，但我担心如果对两个队列使用相同的头文件，两个队列之间的值会崩溃(类似于下面的情况)。
问:对于两个不同的队列，我可以使用相同的队列ADT文件吗？这是队列ADT头文件的代码。
#ifndef H_queueAsLinkedList
#define H_queueAsLinkedList
#include <iostream>
#include <cassert>
#incl
浏览 2提问于2022-02-04得票数 -1
1回答
我只是在学习Scala的时候遇到了一个困难。我有一个继承层次结构，它本质上等同于：
class A {
protected def myMethod() = println("myMethod() from A")
}
class B extends A {
def invokeMyMethod(a: A) = a.myMethod()
}
但是尝试编译这个示例时，我得到了错误"test.scala:7: error: method myMethod cannot be accessed in A“。
我来自Java，我的理解是受保护的成员应该在任何时
浏览 0提问于2011-01-07得票数 9
回答已采纳
我在Scala中有一个特征，一个伴生对象和一个类：
trait A {
protected var foo = "Foo"
}
object B extends A {
}
class B {
println(B.foo)
}
为什么我不能访问foo？我认为foo会成为对象"B“的一个字段。有没有办法做到这一点？
浏览 2提问于2012-12-05得票数 5
回答已采纳
1回答
我正在创建一个模板化的矩阵乘法函数，其中返回的矩阵与左侧矩阵的大小不同。在该函数中，我需要访问要返回矩阵的受保护成员，但得到编译器错误C2248: cannot access protected member。我相信这是因为模板参数的大小不同。
template<typename T, std::size_t r, std::size_t c>
struct Matrix
{
template<std::size_t c2>
Matrix<T, r, c2> operator*(const Matrix<T, c, c2>& rh
浏览 14提问于2018-05-28得票数 1
回答已采纳
4回答
受保护的方法，我们只能在派生类中访问该成员，而内部方法则可以使用对象在同一程序集中的任何类型访问该成员。因此，我是否可以将受保护的内部成员视为同一程序集中的公共成员。和不同程序集中的受保护成员。
编辑：
namespace pracConsole
{
class Class1
{
protected internal int val;
public int hello()
{
Console.WriteLine("This is method pracConsole.hello");
Console.ReadLin
浏览 2提问于2010-04-16得票数 31
回答已采纳
1回答
默认情况下，类内的一切都是私有的。默认情况下，非嵌套类、接口、结构、委托和枚举具有内部可访问性。但这意味着如果所有这些都出现在类中，那么默认情况下一切都将成为私有的。默认情况下，在类中是否有任何类型将成为非私有类型？
PS。只是一种例外情况，比如一个实例变量，我们不能在一个结构中赋值，但是通过使用空合并操作符，我们可以赋值。
浏览 3提问于2013-11-04得票数 1
回答已采纳
我正在学习java中的访问级别，我已经创建了3个类:在包my.inheritance中，我有A类和C类
package my.inheritance;
public class A {
protected int a=15;
}
package my.inheritance;
public class C {
public static void main(String[] args)
{
A a = new A();
System.out.println(a.a);
}
}
在另一个名为my.inheritance.test的包中，我有一个类B试图访问int值为a的受保
浏览 0提问于2012-08-06得票数 9
回答已采纳
1回答
我仍然不明白为什么"Acc obj = new ()“不允许访问超类中受保护的整数，而"Test = new ()”将提供访问权限。
Acc obj =新的Test()；<- NO访问受保护整数
Test obj =新的Test()；<- YES访问受保护的整数
package p1;
public class Acc {
int p;
private int q;
[b]protected int r;[/b]
public int s;
}
package p2;
import p1.Acc;
public class Test extends Acc {
浏览 2提问于2017-05-25得票数 1
回答已采纳
1回答
下面是我处理symmetrix矩阵代码的一部分：
SymmetricMatrix<std::deque<int> > a(3);
SymmetricMatrix<std::list<int> > b(3);
SymmetricMatrix<std::vector<int> > c(4);
SymmetricMatrix<std::list<int> > d(3);
a(1,1) = b(1,1) = c(1,1) = d(1,1) = 7;
a(1,2) = b(2,1) = c(1,2) = d
浏览 1提问于2013-08-15得票数 1
回答已采纳
我有一个带有基类和派生类的简单类层次结构。基具有派生类调用的两个受保护的成员。根据最近的一些C#经验，我认为最好能使接口更加流畅，并允许方法调用的链接，这样this->B()就可以调用this->A()->B()而不是调用this->A()->B()。但是，以下代码将不会编译：
#include <iostream>
class Base
{
protected:
Base* A()
{
std::cout << "A called." << std::endl;
浏览 6提问于2014-02-04得票数 11
回答已采纳
1回答
我必须使用label创建一个asp.net表单。我为这个任务找到了一个示例，并尝试运行它，但没有显示任何来自预期结果的内容。你知道还应该做些什么来运行它吗？(我还处于asp.net的初级阶段。)代码如下：
<%@ Page Language="vb" %>
<script runat="server">
Sub submit(Sender As Object, e As EventArgs)
label1.Text=txt1.Text
End Sub
</script>
<html>
<body>
&l
浏览 2提问于2012-12-30得票数 0
我有下面的Foo类，其中包含了主要的方法。
Foo扩展了Nee。
Foo类在com.package1中，Nee类在com.package2中。
问题是，我无法从Foo类通过其对象访问受保护的Nee方法。为什么？(理论上说，受保护的成员可以由同一包中的子类或类访问)
Foo类如下所示
package com.package1;
import com.package2.Nee;
/**
*
* @author Dilukshan Mahendra
*/
public class Foo extends Nee{
public static void
浏览 1提问于2014-03-13得票数 1
回答已采纳
假设我有这样一门课：
public class ClassA
{
[...]
protected void methodIWantToTest()
{
[...]
}
[...]
}
当我用IntelliJ Idea 13编写单元测试时，当我编写以下内容时，不会出现编译器错误：
public class ClassATest
{
@Test
public void test()
{
final ClassA objectUnderTest = new ClassA();
obj
浏览 3提问于2014-11-12得票数 7
回答已采纳
我正在阅读简单的算法(O‘’Reilly)，并在类图中遇到了这个符号。我的猜测是，这意味着成员是受保护的，但我想看看是否有人确切地知道这是什么意思。
浏览 2提问于2009-01-06得票数 82
回答已采纳
我有一个带有转换构造函数的模板化类Rect，它允许在Rect和反之亦然之间进行转换。但是在编译代码时，编译器会给出一个错误，说明构造函数不能访问类的受保护成员。这是代码：
#include <iostream>
#include <list>
#include <algorithm>
using namespace std;
template< typename T >
class Rect{
protected:
T width, height;
public:
Rect(T a, T b){
width = a;
浏览 4提问于2012-06-12得票数 2
回答已采纳
类的clone()和finalize()被声明为protected。
这里面有什么意义吗？
所有的java类本质上都是Objects类的后代--这一点也不例外。
怎么做？
protected void finalize()
在效果上不同于
void finalize()
浏览 2提问于2014-04-29得票数 0
2回答
using System.IO;
using System;
using Assembly2;
// DLL 1
namespace Assembly1
{
class class1 : class2
{
static void Main()
{
Console.WriteLine(new class2().sample); //Cannot access. Protected means --> accessible to the derived classes right ? (But, note that this is a
浏览 4提问于2014-04-08得票数 1
回答已采纳
我在工作和家里都开始了TDD (我知道我去派对迟到了)。我已经对类的公共方法进行了几次测试。然而，我编写的许多类都有许多受保护的函数。在创建测试类时，是否应该让它子类进行测试，以便对受保护的方法进行覆盖？
谢谢,
联合执行委员会
浏览 6提问于2013-08-14得票数 1
回答已采纳
我有一节课：
template < typename Service >
class BasicIOObject : public boost::asio::basic_io_object<Service>
{
public:
explicit BasicIOObject(
boost::asio::io_service &io_serviceIn, CString& fileNameIn)
: boost::asio::basic_io_object<Service>(io_serviceIn)
浏览 0提问于2015-02-20得票数 0
回答已采纳
我有下面的代码片段：
abstract class Foo {
protected abstract void method(String o);
public void method(Object o) {
System.out.println("method(Object)");
}
}
class Bar extends Foo {
protected void method(String key) {
System.out.println("method(String)");
}
浏览 0提问于2019-07-04得票数 0
回答已采纳
1回答
为什么不允许派生类在模板化时访问其受保护的基类成员？
class MyBase {
protected:
int foo;
};
template<typename Impl>
class Derived : public Impl {
public:
int getfoo() {
return static_cast<Impl*>(this)->foo;
}
};
编译器抱怨foo受到保护。为什么？
error: int MyBase::foo is protected
浏览 0提问于2012-04-11得票数 2
回答已采纳
我正在尝试运行下面的代码，但得到了错误。
#include <iostream>
template <typename T>
class Base {
public :
static T& Get() {
static T t;
return t;
}
};
class Derived : public Base<Derived> {
private :
Derived() {}
// friend Base<Derived>; //un-commenting th
浏览 0提问于2019-02-05得票数 1
回答已采纳
2回答
public class Business {
protected List<BusinessRulesDto> BusinessRules { get; set; }
}
我试过：
businessMockObject.Protected().SetupSet<List>("BusinessRules"，ItExpr.IsAny<List>().Verifiable()；
变量businessMockObject.Protected().SetupGet<List>("BusinessRules&
浏览 0提问于2018-03-28得票数 6
ArrayBuffer扩展了ResizableArray，其中包含一个受保护的方法swap。但是我不能访问交换。我遗漏了什么？
scala> import scala.collection.mutable.ArrayBuffer
import scala.collection.mutable.ArrayBuffer
scala> val x=new ArrayBuffer[Int]()
x: scala.collection.mutable.ArrayBuffer[Int] = ArrayBuffer()
scala> x+=3
scala> x+=5
sca
浏览 1提问于2009-10-31得票数 1
回答已采纳
class A {
public:
A() {auto tmp = &A::foo;}
protected:
void foo() {}
};
class B : public A {
public:
B() {auto tmp = &A::foo;}
};
类A编译没有问题。类B生成一个编译错误：
‘’：foo‘：无法访问在'A’类中声明的受保护成员
为什么，理由是什么？有什么方法可以避免这种情况(如果我需要回调、std::function等的指针)？
浏览 8提问于2014-07-25得票数 7
回答已采纳
我正在创建一个.net托管包装器。所有的代码都是用C++编写的，我正在使用C++/CLI创建一个包装器。
C++类中的一些函数处于受保护级别，因此我无法包装这些函数。每当我试图包装受保护的函数时，我总是得到一个“无法访问在类错误中声明的受保护成员”的消息。
有解决这个问题的办法吗？
浏览 3提问于2011-08-25得票数 0
回答已采纳
想象一下，您想要分配您自己的事件过程：
procedure TSuperObject.DoSomething(Sender: TObject; Button: TMouseButton; Shift: TShiftState; X, Y: Integer);
begin
ShowMessage('Yes, I am doing');
end;
到表单上的任何TWinControl。通常，如果表单上有Panel1 (TPanel)，则可以轻松完成：
Panel1.OnMouseDown:=SuperObject1.DoSomething;
但是，如果你想普遍地去做，怎么才能做到呢
浏览 1提问于2013-08-05得票数 3
回答已采纳
3回答
最近我注意到，您可以使用Moq对抽象基类进行单元测试，而不是在测试中创建实现抽象基类的虚拟类。参见，例如您可以：
public abstract class MyAbstractClass
{
public virtual void MyMethod()
{
// ...
}
}
[Test]
public void MyMethodTest()
{
// Arrange
Mock<MyAbstractClass> mock = new Mock<MyAbstractClass>
浏览 0提问于2011-10-10得票数 33
回答已采纳
在进行了一些实验之后，我了解了一些事情，我想概括如下：
用户定义类的实例的成员函数不仅可以访问它自己的私有数据成员，还可以访问作为参数传递给它们的同一类的其他实例的私有数据成员。
如果这种情况在所有情况下都成立，请告诉我。
浏览 3提问于2015-02-24得票数 2
2回答
我编写了以下愚蠢的策略结构：
template
<typename T>
struct SuperLeague
{
public:
void printLeague(){std::cout << "SuperLegue" << std::endl;};
protected:
//~SuperLeague(){}
};
以及东道班
template
<typename TT,template <typename C> class Policy>
class League: public Policy<TT&
浏览 0提问于2013-05-22得票数 0
回答已采纳
2回答
我是C++的新手，我的问题可能很愚蠢：
我们的A、B和C类定义如下：
class A {
public:
typedef Resouce Money;
};
class B
:public A {
};
class C {
public:
typedef B::Money MyMoney;
};
这有效吗？我很困惑，因为“金钱”在B类中没有明确的定义。
提前感谢！
浏览 1提问于2013-10-25得票数 0
回答已采纳
据我所知，RM应该模拟任何可以被派生类访问的东西。既然受保护的虚拟成员可以从子类访问，那么它不应该是可mockable的吗？
我的理解是RM不支持模仿受保护的虚拟成员。
浏览 0提问于2010-06-17得票数 3
2回答
公共继承很容易。
答:公共B意味着每个A都是B，在大多数编程语言中，比如vb.net和objective，这是唯一的继承类型。
私有继承也很容易，但毫无意义。
答:私人B的意思是A是由B实现的，但是，这是没有意义的，因为这意味着A应该包含B。所有权意味着没有缺点的耦合更少。
那我们就保护了遗产。
有人能跟我解释一下这到底是干什么用的吗？有人说这是一种“作为一种关系”。我对此仍不太清楚。
有没有人有一些示例案例，人们在良好的模式(和良知)中将受保护的继承用于实际的生产用途？
浏览 2提问于2013-11-28得票数 17
回答已采纳
我对基类和子类函数继承感到非常困惑。我有这些课程：
#include <point.h>
class Polygon{
public:
Polygon();
virtual ~Polygon();
void addPoint(Point *p);
std::string getType();
Point* getPoint(int index);
int getNumOfPoints();
int getColor();
virtual int area()=0;
private:
std::vector<
浏览 0提问于2012-11-26得票数 0
1回答
#include <iostream>
#include <cmath>
using namespace std;
class Point
{
protected:
double x,y,z;
double mag;
public:
Point(double a=0.0, double b=0.0, double c=0.0) : x(a), y(b), z(c)
{
mag = sqrt((x*x)+(y*y)+(z*z));
}
浏览 1提问于2018-04-09得票数 3
回答已采纳
1回答
我在class C中获得了一个嵌套声明的class C，在这里，我希望在S的构造函数中重新定义C的成员
public class C {
private int class_state = 0;
private struct S {
public int struct_state;
public S () {
struct_state = class_state;
}
}
public void foo (int state) {
class_s
浏览 4提问于2021-07-31得票数 0
回答已采纳
我正在使用CUDA 11编译一个具有扩展lambda表达式特性的项目，我发现以下代码无法通过使用NVCC (CUDA 11.8)的编译
// test.cu
#include <iostream>
#include "cuda_runtime.h"
#include "device_launch_parameters.h"
#include <type_traits>
template<typename Lam>
__global__ void map(int n, Lam func) {
int tid = blo
浏览 6提问于2022-11-07得票数 1
2回答
我编写了一个包含许多类和函数的c#-控制台项目。我想要从这个项目构建一个DLL，但只让大约3个类的函数可以调用。这些类与其他类有依赖关系，因此必须编译这些依附类，但它们的函数不应该从dll用户调用。
我知道如何在Visual 2019中创建一个简单的DLL，其中包括来自项目的所有函数。
谢谢你的帮忙!
浏览 4提问于2020-04-15得票数 0
回答已采纳
1回答
可能重复：
我曾看到很多关于宣布议员在内部受到保护的真正意义的争论。
在这种情况下，成员的访问修饰符是“受保护的还是内部的”还是“受保护的和内部的”？
浏览 5提问于2012-10-18得票数 0
1回答
我使用以下代码：
BindingFlags flags= BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.Public;
PropertyInfo prop = myObj.GetProperty("Age", flags);
prop不是空的。但是，当我试图从myObj获取所有属性时
foreach(MemberInfo e in myObj.GetType().GetMembers( flags) ) { //neither GetProperties helps
Console.
浏览 0提问于2018-05-09得票数 1
回答已采纳
1回答
C# 7.2引入了private protected修饰符，与internal protected有什么区别？
从医生那里：
私有受保护成员可以通过从包含类派生的类型访问，但只能在其包含的程序集中访问。
这不正是internal protected所做的吗？
浏览 8提问于2018-01-12得票数 12
回答已采纳
Main.java，主包：
package pkgs.main;
import pkgs.test.B;
// Just some method inside the "main class"
void method() {
B b = new B();
b.x ++; // <--- why is this allowed?
}
A.java，主包：
package pkgs.main;
public class A {
protected int x;
}
B.java，测试包：
package pkgs.test;
import p
浏览 1提问于2014-04-16得票数 0
回答已采纳
我有一个程序，我需要在dll和一些应用程序代码之间共享一个基类。然后我有两个不同的派生类，一个在dll中，另一个在主应用程序中。它们中的每一个都有一些静态成员函数，这些函数对nase类中的数据进行操作。(它们需要是静态的，因为在其他地方用作函数指针)。我的问题最简单的形式如下所示。
class Base {
protected:
int var ;
};
class Derived : public Base {
static bool Process( Base *pBase ) {
pBase->var = 2;
return true;
}
};
我的
浏览 0提问于2011-09-05得票数 20
回答已采纳
我在过去的一次考试中偶然发现了这段代码：
#include <iostream>
class cls1
{
protected:
int x;
public:
cls1()
{
x = 13;
}
};
class cls2 : public cls1
{
int y;
public:
cls2()
{
y = 15;
}
int f(cls2 ob)
{
return (ob.x + ob.y);
}
};
int main()
{
浏览 2提问于2020-06-05得票数 0
回答已采纳
1回答
因此，我已经阅读了问题，我理解了模板中依赖名称的前提，以及有时必须如何用this->限定一个方法，以确保编译器能够正确地找到它，然而，我遇到了一个我无法解决的场景。具体来说，当方法所属的对象与*this的类型相同时，但它是不同的对象(可能属于不同的子类)。例如：
#include <iostream>
template<class T>
class A
{
protected:
virtual void foo() = 0;
};
template<class T>
class B : public A<T>
{
};
tem
浏览 0提问于2018-06-04得票数 4
回答已采纳
3回答
考虑类测试
package access;
public class test {
public String s;
protected test(String s){
this.s = s;
System.out.println("access.test constructor");
}
protected void test1(String s){
this.s = s;
System.out.println("access.test test1 method"
浏览 2提问于2014-01-18得票数 0
我在同一个程序集中定义了一个接口和一个抽象基类：
IFoo.cs:
internal interface IFoo { ... }
Base.cs:
public abstract class Base
{
internal protected Base(IFoo foo) { ... }
}
这会产生以下编译器错误：
CS0051: Inconsistent accessibility: parameter type 'IFoo' is less
accessible than method 'Base.Base(IFoo)'
如果我将
浏览 0提问于2013-07-25得票数 14
回答已采纳
扫码
添加站长 进交流群
领取专属 10元无门槛券
手把手带您无忧上云
相关资讯
热门标签
云服务器
ICP备案
实时音视频
对象存储
云直播活动推荐
腾讯云开发者
