Introduction

Auto Layout inside UITableViewCell was much rougher on iOS 7 than on later iOS releases. If you are maintaining older code, the usual problems are incomplete constraints, constraints attached to the wrong view, and relying on automatic row sizing behavior that became smoother only in newer table-view implementations.

The Important Cell Layout Rule

In a table view cell, your constraints should usually be anchored to the cell's contentView, not directly to the cell itself. That is one of the most common causes of warnings and incorrect height calculations in older code.

For example, a label inside a custom cell should be constrained like this:

1self.titleLabel.translatesAutoresizingMaskIntoConstraints = NO;
2
3[self.contentView addSubview:self.titleLabel];
4
5[NSLayoutConstraint activateConstraints:@[
6    [self.titleLabel.topAnchor constraintEqualToAnchor:self.contentView.topAnchor constant:8],
7    [self.titleLabel.leadingAnchor constraintEqualToAnchor:self.contentView.leadingAnchor constant:15],
8    [self.titleLabel.trailingAnchor constraintEqualToAnchor:self.contentView.trailingAnchor constant:-15],
9    [self.titleLabel.bottomAnchor constraintEqualToAnchor:self.contentView.bottomAnchor constant:-8]
10]];

The full top-to-bottom chain is important. If the content does not have enough vertical constraints to define the cell's height, layout becomes ambiguous.

Why iOS 7 Was Especially Sensitive

iOS 7 supported Auto Layout, but the UITableViewCell integration was less forgiving than what developers got used to later. Dynamic-height cells often required more manual sizing logic, and incomplete constraints produced harder-to-diagnose truncation or overlap issues.

That is why old iOS 7 table-view code often contains explicit height calculation methods even when later iOS versions can get by with automaticDimension-style behavior more reliably.

Multiline Labels Need Extra Attention

If the cell uses a multiline label, set numberOfLines = 0 and make sure the label's width is constrained. On older systems, preferredMaxLayoutWidth also mattered more often than developers expected.

self.titleLabel.numberOfLines = 0;
self.titleLabel.preferredMaxLayoutWidth = CGRectGetWidth(self.contentView.bounds) - 30;

Without a stable width, the label cannot compute the correct wrapped height, which then breaks the cell's layout.

A Common Height Calculation Pattern

On legacy codebases, one practical approach is to size an offscreen prototype cell and ask Auto Layout for the compressed fitting size.

1- (CGFloat)tableView:(UITableView *)tableView heightForRowAtIndexPath:(NSIndexPath *)indexPath {
2    static MyCell *sizingCell;
3    static dispatch_once_t onceToken;
4    dispatch_once(&onceToken, ^{
5        sizingCell = [[MyCell alloc] initWithStyle:UITableViewCellStyleDefault reuseIdentifier:nil];
6    });
7
8    [sizingCell configureWithText:self.items[indexPath.row]];
9    [sizingCell setNeedsLayout];
10    [sizingCell layoutIfNeeded];
11
12    CGSize size = [sizingCell.contentView systemLayoutSizeFittingSize:UILayoutFittingCompressedSize];
13    return size.height + 1.0;
14}

This is slower than modern automatic sizing, but it was a common and reliable workaround for older systems.

If you are mixing storyboard-era cells with programmatic constraints in an old codebase, make sure both paths agree on the same layout assumptions. Hidden duplicate constraints from Interface Builder were another common source of confusing iOS 7 cell behavior.

That problem was especially easy to miss during cell reuse.

Common Pitfalls

The biggest pitfall is attaching constraints to the cell instead of contentView. That often behaves unpredictably in reusable cells.

Another issue is missing a full vertical constraint chain from top to bottom. If Auto Layout cannot infer the final height, the row cannot size correctly.

Developers also sometimes forget to disable translatesAutoresizingMaskIntoConstraints, which leaves old autoresizing-mask constraints fighting with the explicit ones.

Finally, when supporting very old iOS behavior, do not assume the newest table-view sizing tricks apply unchanged. Legacy compatibility often needs more explicit height management.

Summary

• In UITableViewCell, constrain subviews to contentView, not the cell itself.
• Dynamic-height cells need a complete vertical constraint chain.
• Multiline labels require stable width constraints and often preferredMaxLayoutWidth in older code.
• iOS 7 table-view Auto Layout was less forgiving than later releases.
• For legacy support, prototype-cell sizing is often more reliable than assuming automatic row height will just work.