Using a Private Property directly vs using Get and Let/Set - class

Question

Beginner VBA programmer here (and beginner to programming in general) looking to learn more about how effective OOP is done.
Can someone explain or provide a reference discussing the benefits/purpose of using - INSIDE of a class module - Private Property Get and/or Let/Set statements in VBA vs accessing properties directly although no manipulation is required of the data?
Example:
I have created a cDimension class (in Excel). This class draws lines as Shape objects, and a few other things that are not relevant. The DrawingScale variable allows the entire drawing to be scaled as desired. Some of the properties require manipulation when Getting/Setting, others don't.
So, for example, pWidth needs to be scaled going in:
'clsDimension
Private pWidth As Single
Private Property Get Width() As Single
Width = pWidth
End Property
Private Property Let Width(w As Single)
pWidth = w / DrawingScale
End Property
But pColor does not require any manipulation, in or out:
Private pColor As Integer
Private Property Get Color() As Integer
Color = pColor
End Property
Private Property Let Color(c As Integer)
pColor = c
End Property
The pWidth property is an instance where using the Private Property Get and Let methods for procedures inside of the class itself makes sense to me. However, my question is: is there any reason to also use Private Property methods to Get and Let/Set the pColor property as well, as I have given them above?
Public Function Line(sht As Worksheet, L As tLine, Optional c = vbBlack) As Shape
Width = DistanceBetweenTwoPoints(L.first.x, L.first.y, _
L.second.x, L.second.y) '<-- pWidth is scaled
Color = c '<-- Vs. just using pColor = c
Set Line = sht.Shapes.AddLine(L.first.x, L.first.y, L.second.x, L.second.y)
End Function
Thanks in advance.

Answer 1

If you are not manipulating the values on the way in or way out, just use public variables. VBA is more like Python than Java or C++ in that there is no real penalty for switching from public variables to "getter/setter" functions down the road.
Let's say you start with the following code:
'clsCar
Public Speed As Double
Public Sub Drive()
MsgBox "Driving at " & Speed & " MPH"
End Sub
'Module1
Sub DriveCar()
Set Car = New clsCar
Car.Speed = 100
Car.Drive 'shows msg: "Driving at 100 MPH"
End Sub
Then you decide that driving that fast is dangerous, so you want to add a "governor" to your vehicle and need to update your class:
'clsCar
Private mSpeed As Double
Private Const SpeedLimit As Double = 55
Public Property Get Speed()
Speed = mSpeed
End Property
Public Property Let Speed(Val As Double)
If Val > SpeedLimit Then
mSpeed = SpeedLimit
ElseIf Val < 0 Then
mSpeed = 0
Else
mSpeed = Val
End If
End Property
Public Sub Drive()
MsgBox "Driving at " & Speed & " MPH"
End Sub
'Module1
'Note that no changes to this code are necessary; the change
' is entirely encapsulated within the class (as it should be)
Sub DriveCar()
Set Car = New clsCar
Car.Speed = 100
Car.Drive 'shows msg: "Driving at 55 MPH"
End Sub
Tim Williams's comment is what you will often hear as justification for unnecessarily using Get/Let/Set in VBA, but that's the byproduct of good advice from other languages (C++ and Java, notably) being misapplied to VBA/VB6.

Answer 2

As always.... it depends. Your x property should definitely be accessed via the letter because the letter performs a calculation on the input.
'clsDimension
Private Let Width(w As Single)
pWidth = w / DrawingScale
End Property
You should NOT access the pWidth variable directly. If you did, you would have to duplicate the pWidth = w / DrawingScale logic elsewhere in your module.
Your pColor property could be a public variable, because there's no logic in getting or setting it. I don't recommend it though. What if later you realize you don't want to allow certain colors? Then you would need logic behind it and you would need to switch to a property anyway. The property is easier to maintain and more semantically correct.

Answer 3

The value I see is reduced code, which you are not taking advantage of in your sample code. You could replace this:
'clsDimension
Private pWidth As Single
Private Property Get Width() As Single
Width = pWidth
End Property
Private Property Let Width(w As Single)
pWidth = w / DrawingScale
End Property
with this:
'clsDimension
Private Property Get Width() As Single
Width = w / DrawingScale
End Property
This eliminates the potential ambiguity of accessing pWidth or the width property since pWidth no longer exists. It also eliminates the potential pitfall of Width being read before it has been written, although it would be wise to add a bit of code that checks that w and DrawingScale have been set to valid values before you read Width.