473,883 Members | 1,610 Online
Bytes | Software Development & Data Engineering Community
+ Post

Home Posts Topics Members FAQ

Managed Overloaded Assignment Operator needed

I need an example of a managed overloaded assignment operator for a
reference class, so I can equate two classes A1 and A2, say called
ARefClass, in this manner: A1=A2;. For some strange reason my C++.NET
2.0 textbook does not have one. I tried to build one using the format
as taught in my regular C++ book, but I keep getting compiler errors.

Some errors claim (contrary to my book) that you cannot use a static
function, that you must use a unitary operator for an assignment, etc.

for example, in traditional C++, this should work:

ARefClass ARefClass::oper ator=(ARefClass AAA) //AAA has a public
variable X
{
X = AAA.X;
return *this;
}

For managed C++, I would imagine this might work:

ARefClass ARefClass::oper ator=(ARefClass AAA) //AAA has a public
variable X

ARefClass^ ARefClass::oper ator =(const ARefClass ^rhs)
{
ARefClass ^ret = gcnew ARefClass();
ret->X = rhs->X;
return ret;
}

But it fails to compile, C2582: An attempt was made to assign to an
object that does not have an assignment operator; and error C2679:
binary '=' : no operator found which takes a right-hand operand of type
'AClass' (or there is no acceptable conversion)

Any ideas? I've also tried other permutations of the above with no
luck (below are some examples).

Thanks!

RL
//ARefClass^ operator =(const ARefClass ^lhs, const ARefClass ^rhs);
// assignment operator (binary operator?) only non-static allowed
// void operator =(const ARefClass ^lhs, const ARefClass ^rhs){};
//void operator =(const ARefClass ^rhs){}; //compiles
ARefClass^ ARefClass::oper ator =(const ARefClass ^rhs);

Dec 30 '06 #1
5 2297
It's interesting that I do have a copy constructor that gets involked
when doing things like ARefClass A2 = A1; or ARefClass A2(A1);

Thus using this copy constructor I could effectively do the same thing
as an assignment operator, but I would like to see if I can do things
like: A2 = A1 + A0; (just thought of this: If I overload the "+" do I
need to overload the "=" in a reference class? I'll have to research
this later today).

Ironically the earlier version of C++.NET used a more bizarre keyword
"op_Assign" , which in some ways is a step forward (reminds the
programmer that the overloaded assignment operator is being used).

RL

raylopez99 wrote:
I need an example of a managed overloaded assignment operator for a
reference class, so I can equate two classes A1 and A2, say called
ARefClass, in this manner: A1=A2;.
Dec 30 '06 #2
I think I found the answer: there is no overloaded assignment operator
for reference classes in managed C++.NET 2.0 (for most ordinary uses at
least).

This works:

AClass^ AClass::operato r+ (AClass^ prhs); //definition in header file

// declaration in .cpp file
AClass^ AClass::operato r+ (AClass^ prhs) //Note: in managed C++.NET
2.0, overloaded "+" is a unitary operator, not a binary operator!
{
AClass^ result = gcnew AClass(this->pubint + prhs->pubint); //using
parametrized normal constructor (not shown here)
// can do other things to result here regarding any embedded
composition classes within AClass result here
return result;
}

// Note: overloaded "=" not necessary in managed reference classes
(for most normal purposes).

/*

Hence, using the above, we can do the following without a overloaded
"="

AClass ^x1 = gcnew AClass(22);
AClass ^x2 = gcnew AClass(33);
AClass ^x3;
x3 = x1 + x2; //works! No need to overload "="

*/
raylopez99 wrote:
I need an example of a managed overloaded assignment operator for a
reference class, so I can equate two classes A1 and A2, say called
ARefClass, in this manner: A1=A2;. For some strange reason my C++.NET
2.0 textbook does not have one. I tried to build one using the format
as taught in my regular C++ book, but I keep getting compiler errors.

Some errors claim (contrary to my book) that you cannot use a static
function, that you must use a unitary operator for an assignment, etc.

for example, in traditional C++, this should work:

ARefClass ARefClass::oper ator=(ARefClass AAA) //AAA has a public
variable X
{
X = AAA.X;
return *this;
}

For managed C++, I would imagine this might work:

ARefClass ARefClass::oper ator=(ARefClass AAA) //AAA has a public
variable X

ARefClass^ ARefClass::oper ator =(const ARefClass ^rhs)
{
ARefClass ^ret = gcnew ARefClass();
ret->X = rhs->X;
return ret;
}

But it fails to compile, C2582: An attempt was made to assign to an
object that does not have an assignment operator; and error C2679:
binary '=' : no operator found which takes a right-hand operand of type
'AClass' (or there is no acceptable conversion)

Any ideas? I've also tried other permutations of the above with no
luck (below are some examples).

Thanks!

RL
//ARefClass^ operator =(const ARefClass ^lhs, const ARefClass ^rhs);
// assignment operator (binary operator?) only non-static allowed
// void operator =(const ARefClass ^lhs, const ARefClass ^rhs){};
//void operator =(const ARefClass ^rhs){}; //compiles
ARefClass^ ARefClass::oper ator =(const ARefClass ^rhs);
Dec 30 '06 #3
Just to complete this thread, I found you can overload the "+" operator
as well, for non-pointer (tracking pointer) instantiated reference
class objects--but, if you do that, you must also overload the
assignment operator (unlike the case for reference classes that are
instantiated with pointers).

So here is the code for such reference classes

// in header
AClass AClass::operato r+ (AClass rhs); //overloaded operator for ref
class not a tracking ptr
AClass AClass::operato r= (AClass rhs); //for above line only
(non-tracking ptr)

// in .CPP

AClass AClass::operato r+ (AClass rhs)
{
AClass result(this->pubint + rhs.pubint); //using a parametrized
normal construtor (not shown) to instantiate the return value 'AClass
result'
//other members here that need to be added
return result;
}

AClass AClass::operato r =(AClass rhs)
{
pubint = rhs.pubint; //equating a member variable
privint = rhs.privint; // " "
privs1 = rhs.privs1; // " "
//other members equalized here, as need be, to equalize the classes,
etc
return *this;
}

// in main.cpp

AClass A, B, C; // reference classes instantiated without tracking
pointers--compare with before in this thread

A = B + C; //now works fine

raylopez99 wrote:
I think I found the answer: there is no overloaded assignment operator
for reference classes in managed C++.NET 2.0 (for most ordinary uses at
least).

This works:

AClass^ AClass::operato r+ (AClass^ prhs); //definition in header file

// declaration in .cpp file
AClass^ AClass::operato r+ (AClass^ prhs) //Note: in managed C++.NET
2.0, overloaded "+" is a unitary operator, not a binary operator!
{
AClass^ result = gcnew AClass(this->pubint + prhs->pubint); //using
parametrized normal constructor (not shown here)
// can do other things to result here regarding any embedded
composition classes within AClass result here
return result;
}

// Note: overloaded "=" not necessary in managed reference classes
(for most normal purposes).

/*

Hence, using the above, we can do the following without a overloaded
"="

AClass ^x1 = gcnew AClass(22);
AClass ^x2 = gcnew AClass(33);
AClass ^x3;
x3 = x1 + x2; //works! No need to overload "="

*/
raylopez99 wrote:
I need an example of a managed overloaded assignment operator for a
reference class, so I can equate two classes A1 and A2, say called
ARefClass, in this manner: A1=A2;. For some strange reason my C++.NET
2.0 textbook does not have one. I tried to build one using the format
as taught in my regular C++ book, but I keep getting compiler errors.

Some errors claim (contrary to my book) that you cannot use a static
function, that you must use a unitary operator for an assignment, etc.

for example, in traditional C++, this should work:

ARefClass ARefClass::oper ator=(ARefClass AAA) //AAA has a public
variable X
{
X = AAA.X;
return *this;
}

For managed C++, I would imagine this might work:

ARefClass ARefClass::oper ator=(ARefClass AAA) //AAA has a public
variable X

ARefClass^ ARefClass::oper ator =(const ARefClass ^rhs)
{
ARefClass ^ret = gcnew ARefClass();
ret->X = rhs->X;
return ret;
}

But it fails to compile, C2582: An attempt was made to assign to an
object that does not have an assignment operator; and error C2679:
binary '=' : no operator found which takes a right-hand operand of type
'AClass' (or there is no acceptable conversion)

Any ideas? I've also tried other permutations of the above with no
luck (below are some examples).

Thanks!

RL
//ARefClass^ operator =(const ARefClass ^lhs, const ARefClass ^rhs);
// assignment operator (binary operator?) only non-static allowed
// void operator =(const ARefClass ^lhs, const ARefClass ^rhs){};
//void operator =(const ARefClass ^rhs){}; //compiles
ARefClass^ ARefClass::oper ator =(const ARefClass ^rhs);
Dec 30 '06 #4
Hi raylopez99,

to overload an assignment operator look at the definition of
msclr::auto_han dle in msclr/auto_handle.h.

Howver, you should be aware that this only works in the context of
implicitly dereferenced variables (e.g. Stack-like) variables. Therefore, it
is likely not what you want.

Marcus

"raylopez99 " <ra********@yah oo.comwrote in message
news:11******** *************@a 3g2000cwd.googl egroups.com...
Just to complete this thread, I found you can overload the "+" operator
as well, for non-pointer (tracking pointer) instantiated reference
class objects--but, if you do that, you must also overload the
assignment operator (unlike the case for reference classes that are
instantiated with pointers).

So here is the code for such reference classes

// in header
AClass AClass::operato r+ (AClass rhs); //overloaded operator for ref
class not a tracking ptr
AClass AClass::operato r= (AClass rhs); //for above line only
(non-tracking ptr)

// in .CPP

AClass AClass::operato r+ (AClass rhs)
{
AClass result(this->pubint + rhs.pubint); //using a parametrized
normal construtor (not shown) to instantiate the return value 'AClass
result'
//other members here that need to be added
return result;
}

AClass AClass::operato r =(AClass rhs)
{
pubint = rhs.pubint; //equating a member variable
privint = rhs.privint; // " "
privs1 = rhs.privs1; // " "
//other members equalized here, as need be, to equalize the classes,
etc
return *this;
}

// in main.cpp

AClass A, B, C; // reference classes instantiated without tracking
pointers--compare with before in this thread

A = B + C; //now works fine

raylopez99 wrote:
>I think I found the answer: there is no overloaded assignment operator
for reference classes in managed C++.NET 2.0 (for most ordinary uses at
least).

This works:

AClass^ AClass::operato r+ (AClass^ prhs); //definition in header file

// declaration in .cpp file
AClass^ AClass::operato r+ (AClass^ prhs) //Note: in managed C++.NET
2.0, overloaded "+" is a unitary operator, not a binary operator!
{
AClass^ result = gcnew AClass(this->pubint + prhs->pubint); //using
parametrized normal constructor (not shown here)
// can do other things to result here regarding any embedded
composition classes within AClass result here
return result;
}

// Note: overloaded "=" not necessary in managed reference classes
(for most normal purposes).

/*

Hence, using the above, we can do the following without a overloaded
"="

AClass ^x1 = gcnew AClass(22);
AClass ^x2 = gcnew AClass(33);
AClass ^x3;
x3 = x1 + x2; //works! No need to overload "="

*/
raylopez99 wrote:
I need an example of a managed overloaded assignment operator for a
reference class, so I can equate two classes A1 and A2, say called
ARefClass, in this manner: A1=A2;. For some strange reason my C++.NET
2.0 textbook does not have one. I tried to build one using the format
as taught in my regular C++ book, but I keep getting compiler errors.

Some errors claim (contrary to my book) that you cannot use a static
function, that you must use a unitary operator for an assignment, etc.

for example, in traditional C++, this should work:

ARefClass ARefClass::oper ator=(ARefClass AAA) //AAA has a public
variable X
{
X = AAA.X;
return *this;
}

For managed C++, I would imagine this might work:

ARefClass ARefClass::oper ator=(ARefClass AAA) //AAA has a public
variable X

ARefClass^ ARefClass::oper ator =(const ARefClass ^rhs)
{
ARefClass ^ret = gcnew ARefClass();
ret->X = rhs->X;
return ret;
}

But it fails to compile, C2582: An attempt was made to assign to an
object that does not have an assignment operator; and error C2679:
binary '=' : no operator found which takes a right-hand operand of type
'AClass' (or there is no acceptable conversion)

Any ideas? I've also tried other permutations of the above with no
luck (below are some examples).

Thanks!

RL
//ARefClass^ operator =(const ARefClass ^lhs, const ARefClass ^rhs);
// assignment operator (binary operator?) only non-static allowed
// void operator =(const ARefClass ^lhs, const ARefClass ^rhs){};
//void operator =(const ARefClass ^rhs){}; //compiles
ARefClass^ ARefClass::oper ator =(const ARefClass ^rhs);

Dec 31 '06 #5
Hi Marcus,

I took a quick look at the auto_handle.h header definition; thanks,
>From the example in this thread it seems the overloaded assignment
operator is working for my purposes, so I don't quite understand your
statement "Therefore, it is likely not what you want."

Can you give an example of non-stack-like (heap) variables?

Below are some examples of both stack-like and heap-like (tracking
pointer/handles used) reference class examples where the "+" and "="
are overloaded, as per this thread.

//////////////////////////
/*
AClass is a reference class having a public member variable 'pubint'.
It also has a copy constructor, and two overloaded operators for "+",
but only one overload operator for "=" (not needed for
tracking-pointer/handle version)

Refer to this thread for definitions and declarations

*/

// first example, using tracking-pointer/handles to instantiate AClass,
heap-like?

AClass ^x4A = gcnew AClass;
//or AClass ^x4A; gives same thing (no need to initialize)
AClass ^x5A = gcnew AClass(40);
AClass ^x6A = gcnew AClass(60);
x4A = x5A->operator+(x6A) ; //equivalent to x4A = x5A + x6A; //also
works
x4A->pubint == 100; //gives output "100" for pubint, as
expected
/* in this example, no copy constructor called and ONLY the
"+" overloaded operator called; the overloaded assignment operator "="
is not called */

// second example, using normal constructor (no
tracking-pointer/handles)-stack-like?
AClass AA(999);
AClass BB(1000);
AClass CC(1001);
CC = AA + BB; //gives output, for 'pubint', of 1999 (not 1001), as
expected
//copy constructor called and overloaded operators "+" and
"=" both called.

// third example, using "%" indirection operator and tracking pointer
-stack-like?

AClass DD(12), DD2(133), DD3;
AClass ^pDD, ^pDD2;

pDD=%DD;
pDD2=%DD2;
DD3 = *pDD + *pDD2;
//DD3.pubint == 145 //(12 + 133). //note dot operator not
'->' used to access pubint
//copy constructor called and overloaded operators "+" and
"=" both called, like ex. 2

//////////////////////////
The only downside to all of this is that lots of coding has to be done
(to deep copy over each member of a class comprising a composition,
that can include other classes). Lots of times you can let the normal
constructor do the copying, when inside the overloaded operators (see
this thread, note at the normal constructor or at gcnew, input the
parameters you want copied), but for arrays that are composite members,
you have to manually copy each element of the array (seems to me).
Lots of work therefore. Also for the non-tracking pointer/handle
version (second and third example above) the copy constructor gets
called a lot. The copy constructor also of course has to do a deep
copy of every member in the class AClass, which is tedious to code.
Also, you can use 'const' in the definition/declaration of each
overloaded operator, i.e.:

AClass^ AClass::operato r+ (const AClass^ prhs); //compiles and works
fine.
AClass AClass::operato r+ (const AClass rhs); //compiles and works fine

AClass AClass::operato r= (const AClass rhs); //" ", used with above
line only, not with AClass^

Am I missing some hidden potential bug in all of this?

Please let me know.

RL

Marcus Heege wrote:
Hi raylopez99,

to overload an assignment operator look at the definition of
msclr::auto_han dle in msclr/auto_handle.h.

Howver, you should be aware that this only works in the context of
implicitly dereferenced variables (e.g. Stack-like) variables. Therefore, it
is likely not what you want.

Marcus

"raylopez99 " <ra********@yah oo.comwrote in message
news:11******** *************@a 3g2000cwd.googl egroups.com...
Just to complete this thread, I found you can overload the "+" operator
as well, for non-pointer (tracking pointer) instantiated reference
class objects--but, if you do that, you must also overload the
assignment operator (unlike the case for reference classes that are
instantiated with pointers).

So here is the code for such reference classes

// in header
AClass AClass::operato r+ (AClass rhs); //overloaded operator for ref
class not a tracking ptr
AClass AClass::operato r= (AClass rhs); //for above line only
(non-tracking ptr)

// in .CPP

AClass AClass::operato r+ (AClass rhs)
{
AClass result(this->pubint + rhs.pubint); //using a parametrized
normal construtor (not shown) to instantiate the return value 'AClass
result'
//other members here that need to be added
return result;
}

AClass AClass::operato r =(AClass rhs)
{
pubint = rhs.pubint; //equating a member variable
privint = rhs.privint; // " "
privs1 = rhs.privs1; // " "
//other members equalized here, as need be, to equalize the classes,
etc
return *this;
}

// in main.cpp

AClass A, B, C; // reference classes instantiated without tracking
pointers--compare with before in this thread

A = B + C; //now works fine

raylopez99 wrote:
I think I found the answer: there is no overloaded assignment operator
for reference classes in managed C++.NET 2.0 (for most ordinary uses at
least).

This works:

AClass^ AClass::operato r+ (AClass^ prhs); //definition in header file

// declaration in .cpp file
AClass^ AClass::operato r+ (AClass^ prhs) //Note: in managed C++.NET
2.0, overloaded "+" is a unitary operator, not a binary operator!
{
AClass^ result = gcnew AClass(this->pubint + prhs->pubint); //using
parametrized normal constructor (not shown here)
// can do other things to result here regarding any embedded
composition classes within AClass result here
return result;
}

// Note: overloaded "=" not necessary in managed reference classes
(for most normal purposes).

/*

Hence, using the above, we can do the following without a overloaded
"="

AClass ^x1 = gcnew AClass(22);
AClass ^x2 = gcnew AClass(33);
AClass ^x3;
x3 = x1 + x2; //works! No need to overload "="

*/
raylopez99 wrote:
I need an example of a managed overloaded assignment operator for a
reference class, so I can equate two classes A1 and A2, say called
ARefClass, in this manner: A1=A2;. For some strange reason my C++.NET
2.0 textbook does not have one. I tried to build one using the format
as taught in my regular C++ book, but I keep getting compiler errors.

Some errors claim (contrary to my book) that you cannot use a static
function, that you must use a unitary operator for an assignment, etc.

for example, in traditional C++, this should work:

ARefClass ARefClass::oper ator=(ARefClass AAA) //AAA has a public
variable X
{
X = AAA.X;
return *this;
}

For managed C++, I would imagine this might work:

ARefClass ARefClass::oper ator=(ARefClass AAA) //AAA has a public
variable X

ARefClass^ ARefClass::oper ator =(const ARefClass ^rhs)
{
ARefClass ^ret = gcnew ARefClass();
ret->X = rhs->X;
return ret;
}

But it fails to compile, C2582: An attempt was made to assign to an
object that does not have an assignment operator; and error C2679:
binary '=' : no operator found which takes a right-hand operand of type
'AClass' (or there is no acceptable conversion)

Any ideas? I've also tried other permutations of the above with no
luck (below are some examples).

Thanks!

RL
//ARefClass^ operator =(const ARefClass ^lhs, const ARefClass ^rhs);
// assignment operator (binary operator?) only non-static allowed
// void operator =(const ARefClass ^lhs, const ARefClass ^rhs){};
//void operator =(const ARefClass ^rhs){}; //compiles
ARefClass^ ARefClass::oper ator =(const ARefClass ^rhs);
Dec 31 '06 #6

This thread has been closed and replies have been disabled. Please start a new discussion.

Similar topics

8
17888
by: Nitin Bhardwaj | last post by:
Thanx in advance for the response... I wanna enquire ( as it is asked many a times in Interviews that i face as an Engg PostGraduate ) about the overloading capability of the C++ Language. Why can't the = (assignment) operator be overloaded as a friend function ? I work in VS 6.0 ( Win2000 ) as when i referred the MSDN documen'n it said the following :
5
6895
by: Andy Jarrell | last post by:
I'm trying to inherit from a specific class that has an overloaded operator. The problem I'm getting is that certain overloaded operators don't seem to come with the inheritance. For example: // TestA.h --------------------------------------- #include <iostream> enum Aval { FIRST_VALUE,
4
1830
by: August1 | last post by:
I've written an interface and implementation file along with a client source file that allows the use of an overloaded subtraction operator. However, when using the program, I'm running into a memory problem that I'm not readily seeing that lies within the overloaded operator - I think pertaining to the temporary class object that is created and used to return a value of the operands and the pointer variable of the class. Could someone...
2
1694
by: Tony Johansson | last post by:
Hello Experts!! I have two small classes called Intvektor and Matris shown at the bottom and a main. Class Intvektor will create a one dimension array of integer by allocate memory dynamically as you can see in the constructor. Class Matris should create a matris by using class Intvektor. So what I want to have is a pointer to an array of Intvektor and in each positionindex in this array will I have a pointer to an array of Intvektor
12
2237
by: Jack Daly | last post by:
I've inherited some code which uses an undocumented feature of a third-party vendor's library. Essentially, this vendor has kept the details of an interface struct secret, but we can pass a pointer to this struct to other vendor routines. The struct describes a complex time-varying object, but it basically boils down to an integer, and there are access routines to get to the current value of this integer. My problem is: 1) Our code is...
2
7383
by: B. Williams | last post by:
I have an assignment for school to Overload the operators << and >and I have written the code, but I have a problem with the insertion string function. I can't get it to recognize the second of number that are input so it selects the values from the default constructor. Can someone assist me with the insertion function. The code is below. // Definition of class Complex #ifndef COMPLEX1_H
5
2289
by: sam_cit | last post by:
Hi Everyone, I was just wondering, about the overloaded assignment operator for user defined objects. It is used to make sure that the following works properly, obj1 = obj; so the overloaded operator function performs the necessary copy of obj's member in to obj1. Can't the same be done using copy
2
2121
by: subramanian100in | last post by:
overloaded operator=() -------------------------------- overloaded assignment operator should be a non-static MEMBER function of a class. This ensures that the first operand is an lvalue. If the overloaded assignment operator function is allowed to be a non- member function then we may be able to write the following: Suppose we have a class Test for which operator+() is defined, suppose we have
3
3925
by: jr.freester | last post by:
I have created to classes Matrix and System. System is made up of type matrix. ---------------------------------------------------------------------------------- class Matrix { private: int row, col; double *data public: Matrix(const int& M, const int& N): row(M), col(N)
0
9942
marktang
by: marktang | last post by:
ONU (Optical Network Unit) is one of the key components for providing high-speed Internet services. Its primary function is to act as an endpoint device located at the user's premises. However, people are often confused as to whether an ONU can Work As a Router. In this blog post, we’ll explore What is ONU, What Is Router, ONU & Router’s main usage, and What is the difference between ONU and Router. Let’s take a closer look ! Part I. Meaning of...
0
9792
by: Hystou | last post by:
Most computers default to English, but sometimes we require a different language, especially when relocating. Forgot to request a specific language before your computer shipped? No problem! You can effortlessly switch the default language on Windows 10 without reinstalling. I'll walk you through it. First, let's disable language synchronization. With a Microsoft account, language settings sync across devices. To prevent any complications,...
0
11148
Oralloy
by: Oralloy | last post by:
Hello folks, I am unable to find appropriate documentation on the type promotion of bit-fields when using the generalised comparison operator "<=>". The problem is that using the GNU compilers, it seems that the internal comparison operator "<=>" tries to promote arguments from unsigned to signed. This is as boiled down as I can make it. Here is my compilation command: g++-12 -std=c++20 -Wnarrowing bit_field.cpp Here is the code in...
1
10857
by: Hystou | last post by:
Overview: Windows 11 and 10 have less user interface control over operating system update behaviour than previous versions of Windows. In Windows 11 and 10, there is no way to turn off the Windows Update option using the Control Panel or Settings app; it automatically checks for updates and installs any it finds, whether you like it or not. For most users, this new feature is actually very convenient. If you want to control the update process,...
1
7974
isladogs
by: isladogs | last post by:
The next Access Europe User Group meeting will be on Wednesday 1 May 2024 starting at 18:00 UK time (6PM UTC+1) and finishing by 19:30 (7.30PM). In this session, we are pleased to welcome a new presenter, Adolph Dupré who will be discussing some powerful techniques for using class modules. He will explain when you may want to use classes instead of User Defined Types (UDT). For example, to manage the data in unbound forms. Adolph will...
0
7133
by: conductexam | last post by:
I have .net C# application in which I am extracting data from word file and save it in database particularly. To store word all data as it is I am converting the whole word file firstly in HTML and then checking html paragraph one by one. At the time of converting from word file to html my equations which are in the word document file was convert into image. Globals.ThisAddIn.Application.ActiveDocument.Select();...
0
5801
by: TSSRALBI | last post by:
Hello I'm a network technician in training and I need your help. I am currently learning how to create and manage the different types of VPNs and I have a question about LAN-to-LAN VPNs. The last exercise I practiced was to create a LAN-to-LAN VPN between two Pfsense firewalls, by using IPSEC protocols. I succeeded, with both firewalls in the same network. But I'm wondering if it's possible to do the same thing, with 2 Pfsense firewalls...
1
4618
by: 6302768590 | last post by:
Hai team i want code for transfer the data from one system to another through IP address by using C# our system has to for every 5mins then we have to update the data what the data is updated we have to send another system
2
4223
muto222
by: muto222 | last post by:
How can i add a mobile payment intergratation into php mysql website.

By using Bytes.com and it's services, you agree to our Privacy Policy and Terms of Use.

To disable or enable advertisements and analytics tracking please visit the manage ads & tracking page.